<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01//EN" "http://www.w3.org/TR/html4/strict.dtd">
<html>
<head>
  <meta http-equiv="Content-Type" content="text/html; charset=utf-8">
  <title>std.encoding</title>
  <link href="html.css" rel="stylesheet" type="text/css">
</head>
<body>
<table><tr>
<td class="linescolumn"><a id="L1" href="#L1">1</a><a id="L2" href="#L2">2</a><a id="L3" href="#L3">3</a><a id="L4" href="#L4">4</a><a id="L5" href="#L5">5</a><a id="L6" href="#L6">6</a><a id="L7" href="#L7">7</a><a id="L8" href="#L8">8</a><a id="L9" href="#L9">9</a><a id="L10" href="#L10">10</a><a id="L11" href="#L11">11</a><a id="L12" href="#L12">12</a><a id="L13" href="#L13">13</a><a id="L14" href="#L14">14</a><a id="L15" href="#L15">15</a><a id="L16" href="#L16">16</a><a id="L17" href="#L17">17</a><a id="L18" href="#L18">18</a><a id="L19" href="#L19">19</a><a id="L20" href="#L20">20</a><a id="L21" href="#L21">21</a><a id="L22" href="#L22">22</a><a id="L23" href="#L23">23</a><a id="L24" href="#L24">24</a><a id="L25" href="#L25">25</a><a id="L26" href="#L26">26</a><a id="L27" href="#L27">27</a><a id="L28" href="#L28">28</a><a id="L29" href="#L29">29</a><a id="L30" href="#L30">30</a><a id="L31" href="#L31">31</a><a id="L32" href="#L32">32</a><a id="L33" href="#L33">33</a><a id="L34" href="#L34">34</a><a id="L35" href="#L35">35</a><a id="L36" href="#L36">36</a><a id="L37" href="#L37">37</a><a id="L38" href="#L38">38</a><a id="L39" href="#L39">39</a><a id="L40" href="#L40">40</a><a id="L41" href="#L41">41</a><a id="L42" href="#L42">42</a><a id="L43" href="#L43">43</a><a id="L44" href="#L44">44</a><a id="L45" href="#L45">45</a><a id="L46" href="#L46">46</a><a id="L47" href="#L47">47</a><a id="L48" href="#L48">48</a><a id="L49" href="#L49">49</a><a id="L50" href="#L50">50</a><a id="L51" href="#L51">51</a><a id="L52" href="#L52">52</a><a id="L53" href="#L53">53</a><a id="L54" href="#L54">54</a><a id="L55" href="#L55">55</a><a id="L56" href="#L56">56</a><a id="L57" href="#L57">57</a><a id="L58" href="#L58">58</a><a id="L59" href="#L59">59</a><a id="L60" href="#L60">60</a><a id="L61" href="#L61">61</a><a id="L62" href="#L62">62</a><a id="L63" href="#L63">63</a><a id="L64" href="#L64">64</a><a id="L65" href="#L65">65</a><a id="L66" href="#L66">66</a><a id="L67" href="#L67">67</a><a id="L68" href="#L68">68</a><a id="L69" href="#L69">69</a><a id="L70" href="#L70">70</a><a id="L71" href="#L71">71</a><a id="L72" href="#L72">72</a><a id="L73" href="#L73">73</a><a id="L74" href="#L74">74</a><a id="L75" href="#L75">75</a><a id="L76" href="#L76">76</a><a id="L77" href="#L77">77</a><a id="L78" href="#L78">78</a><a id="L79" href="#L79">79</a><a id="L80" href="#L80">80</a><a id="L81" href="#L81">81</a><a id="L82" href="#L82">82</a><a id="L83" href="#L83">83</a><a id="L84" href="#L84">84</a><a id="L85" href="#L85">85</a><a id="L86" href="#L86">86</a><a id="L87" href="#L87">87</a><a id="L88" href="#L88">88</a><a id="L89" href="#L89">89</a><a id="L90" href="#L90">90</a><a id="L91" href="#L91">91</a><a id="L92" href="#L92">92</a><a id="L93" href="#L93">93</a><a id="L94" href="#L94">94</a><a id="L95" href="#L95">95</a><a id="L96" href="#L96">96</a><a id="L97" href="#L97">97</a><a id="L98" href="#L98">98</a><a id="L99" href="#L99">99</a><a id="L100" href="#L100">100</a><a id="L101" href="#L101">101</a><a id="L102" href="#L102">102</a><a id="L103" href="#L103">103</a><a id="L104" href="#L104">104</a><a id="L105" href="#L105">105</a><a id="L106" href="#L106">106</a><a id="L107" href="#L107">107</a><a id="L108" href="#L108">108</a><a id="L109" href="#L109">109</a><a id="L110" href="#L110">110</a><a id="L111" href="#L111">111</a><a id="L112" href="#L112">112</a><a id="L113" href="#L113">113</a><a id="L114" href="#L114">114</a><a id="L115" href="#L115">115</a><a id="L116" href="#L116">116</a><a id="L117" href="#L117">117</a><a id="L118" href="#L118">118</a><a id="L119" href="#L119">119</a><a id="L120" href="#L120">120</a><a id="L121" href="#L121">121</a><a id="L122" href="#L122">122</a><a id="L123" href="#L123">123</a><a id="L124" href="#L124">124</a><a id="L125" href="#L125">125</a><a id="L126" href="#L126">126</a><a id="L127" href="#L127">127</a><a id="L128" href="#L128">128</a><a id="L129" href="#L129">129</a><a id="L130" href="#L130">130</a><a id="L131" href="#L131">131</a><a id="L132" href="#L132">132</a><a id="L133" href="#L133">133</a><a id="L134" href="#L134">134</a><a id="L135" href="#L135">135</a><a id="L136" href="#L136">136</a><a id="L137" href="#L137">137</a><a id="L138" href="#L138">138</a><a id="L139" href="#L139">139</a><a id="L140" href="#L140">140</a><a id="L141" href="#L141">141</a><a id="L142" href="#L142">142</a><a id="L143" href="#L143">143</a><a id="L144" href="#L144">144</a><a id="L145" href="#L145">145</a><a id="L146" href="#L146">146</a><a id="L147" href="#L147">147</a><a id="L148" href="#L148">148</a><a id="L149" href="#L149">149</a><a id="L150" href="#L150">150</a><a id="L151" href="#L151">151</a><a id="L152" href="#L152">152</a><a id="L153" href="#L153">153</a><a id="L154" href="#L154">154</a><a id="L155" href="#L155">155</a><a id="L156" href="#L156">156</a><a id="L157" href="#L157">157</a><a id="L158" href="#L158">158</a><a id="L159" href="#L159">159</a><a id="L160" href="#L160">160</a><a id="L161" href="#L161">161</a><a id="L162" href="#L162">162</a><a id="L163" href="#L163">163</a><a id="L164" href="#L164">164</a><a id="L165" href="#L165">165</a><a id="L166" href="#L166">166</a><a id="L167" href="#L167">167</a><a id="L168" href="#L168">168</a><a id="L169" href="#L169">169</a><a id="L170" href="#L170">170</a><a id="L171" href="#L171">171</a><a id="L172" href="#L172">172</a><a id="L173" href="#L173">173</a><a id="L174" href="#L174">174</a><a id="L175" href="#L175">175</a><a id="L176" href="#L176">176</a><a id="L177" href="#L177">177</a><a id="L178" href="#L178">178</a><a id="L179" href="#L179">179</a><a id="L180" href="#L180">180</a><a id="L181" href="#L181">181</a><a id="L182" href="#L182">182</a><a id="L183" href="#L183">183</a><a id="L184" href="#L184">184</a><a id="L185" href="#L185">185</a><a id="L186" href="#L186">186</a><a id="L187" href="#L187">187</a><a id="L188" href="#L188">188</a><a id="L189" href="#L189">189</a><a id="L190" href="#L190">190</a><a id="L191" href="#L191">191</a><a id="L192" href="#L192">192</a><a id="L193" href="#L193">193</a><a id="L194" href="#L194">194</a><a id="L195" href="#L195">195</a><a id="L196" href="#L196">196</a><a id="L197" href="#L197">197</a><a id="L198" href="#L198">198</a><a id="L199" href="#L199">199</a><a id="L200" href="#L200">200</a><a id="L201" href="#L201">201</a><a id="L202" href="#L202">202</a><a id="L203" href="#L203">203</a><a id="L204" href="#L204">204</a><a id="L205" href="#L205">205</a><a id="L206" href="#L206">206</a><a id="L207" href="#L207">207</a><a id="L208" href="#L208">208</a><a id="L209" href="#L209">209</a><a id="L210" href="#L210">210</a><a id="L211" href="#L211">211</a><a id="L212" href="#L212">212</a><a id="L213" href="#L213">213</a><a id="L214" href="#L214">214</a><a id="L215" href="#L215">215</a><a id="L216" href="#L216">216</a><a id="L217" href="#L217">217</a><a id="L218" href="#L218">218</a><a id="L219" href="#L219">219</a><a id="L220" href="#L220">220</a><a id="L221" href="#L221">221</a><a id="L222" href="#L222">222</a><a id="L223" href="#L223">223</a><a id="L224" href="#L224">224</a><a id="L225" href="#L225">225</a><a id="L226" href="#L226">226</a><a id="L227" href="#L227">227</a><a id="L228" href="#L228">228</a><a id="L229" href="#L229">229</a><a id="L230" href="#L230">230</a><a id="L231" href="#L231">231</a><a id="L232" href="#L232">232</a><a id="L233" href="#L233">233</a><a id="L234" href="#L234">234</a><a id="L235" href="#L235">235</a><a id="L236" href="#L236">236</a><a id="L237" href="#L237">237</a><a id="L238" href="#L238">238</a><a id="L239" href="#L239">239</a><a id="L240" href="#L240">240</a><a id="L241" href="#L241">241</a><a id="L242" href="#L242">242</a><a id="L243" href="#L243">243</a><a id="L244" href="#L244">244</a><a id="L245" href="#L245">245</a><a id="L246" href="#L246">246</a><a id="L247" href="#L247">247</a><a id="L248" href="#L248">248</a><a id="L249" href="#L249">249</a><a id="L250" href="#L250">250</a><a id="L251" href="#L251">251</a><a id="L252" href="#L252">252</a><a id="L253" href="#L253">253</a><a id="L254" href="#L254">254</a><a id="L255" href="#L255">255</a><a id="L256" href="#L256">256</a><a id="L257" href="#L257">257</a><a id="L258" href="#L258">258</a><a id="L259" href="#L259">259</a><a id="L260" href="#L260">260</a><a id="L261" href="#L261">261</a><a id="L262" href="#L262">262</a><a id="L263" href="#L263">263</a><a id="L264" href="#L264">264</a><a id="L265" href="#L265">265</a><a id="L266" href="#L266">266</a><a id="L267" href="#L267">267</a><a id="L268" href="#L268">268</a><a id="L269" href="#L269">269</a><a id="L270" href="#L270">270</a><a id="L271" href="#L271">271</a><a id="L272" href="#L272">272</a><a id="L273" href="#L273">273</a><a id="L274" href="#L274">274</a><a id="L275" href="#L275">275</a><a id="L276" href="#L276">276</a><a id="L277" href="#L277">277</a><a id="L278" href="#L278">278</a><a id="L279" href="#L279">279</a><a id="L280" href="#L280">280</a><a id="L281" href="#L281">281</a><a id="L282" href="#L282">282</a><a id="L283" href="#L283">283</a><a id="L284" href="#L284">284</a><a id="L285" href="#L285">285</a><a id="L286" href="#L286">286</a><a id="L287" href="#L287">287</a><a id="L288" href="#L288">288</a><a id="L289" href="#L289">289</a><a id="L290" href="#L290">290</a><a id="L291" href="#L291">291</a><a id="L292" href="#L292">292</a><a id="L293" href="#L293">293</a><a id="L294" href="#L294">294</a><a id="L295" href="#L295">295</a><a id="L296" href="#L296">296</a><a id="L297" href="#L297">297</a><a id="L298" href="#L298">298</a><a id="L299" href="#L299">299</a><a id="L300" href="#L300">300</a><a id="L301" href="#L301">301</a><a id="L302" href="#L302">302</a><a id="L303" href="#L303">303</a><a id="L304" href="#L304">304</a><a id="L305" href="#L305">305</a><a id="L306" href="#L306">306</a><a id="L307" href="#L307">307</a><a id="L308" href="#L308">308</a><a id="L309" href="#L309">309</a><a id="L310" href="#L310">310</a><a id="L311" href="#L311">311</a><a id="L312" href="#L312">312</a><a id="L313" href="#L313">313</a><a id="L314" href="#L314">314</a><a id="L315" href="#L315">315</a><a id="L316" href="#L316">316</a><a id="L317" href="#L317">317</a><a id="L318" href="#L318">318</a><a id="L319" href="#L319">319</a><a id="L320" href="#L320">320</a><a id="L321" href="#L321">321</a><a id="L322" href="#L322">322</a><a id="L323" href="#L323">323</a><a id="L324" href="#L324">324</a><a id="L325" href="#L325">325</a><a id="L326" href="#L326">326</a><a id="L327" href="#L327">327</a><a id="L328" href="#L328">328</a><a id="L329" href="#L329">329</a><a id="L330" href="#L330">330</a><a id="L331" href="#L331">331</a><a id="L332" href="#L332">332</a><a id="L333" href="#L333">333</a><a id="L334" href="#L334">334</a><a id="L335" href="#L335">335</a><a id="L336" href="#L336">336</a><a id="L337" href="#L337">337</a><a id="L338" href="#L338">338</a><a id="L339" href="#L339">339</a><a id="L340" href="#L340">340</a><a id="L341" href="#L341">341</a><a id="L342" href="#L342">342</a><a id="L343" href="#L343">343</a><a id="L344" href="#L344">344</a><a id="L345" href="#L345">345</a><a id="L346" href="#L346">346</a><a id="L347" href="#L347">347</a><a id="L348" href="#L348">348</a><a id="L349" href="#L349">349</a><a id="L350" href="#L350">350</a><a id="L351" href="#L351">351</a><a id="L352" href="#L352">352</a><a id="L353" href="#L353">353</a><a id="L354" href="#L354">354</a><a id="L355" href="#L355">355</a><a id="L356" href="#L356">356</a><a id="L357" href="#L357">357</a><a id="L358" href="#L358">358</a><a id="L359" href="#L359">359</a><a id="L360" href="#L360">360</a><a id="L361" href="#L361">361</a><a id="L362" href="#L362">362</a><a id="L363" href="#L363">363</a><a id="L364" href="#L364">364</a><a id="L365" href="#L365">365</a><a id="L366" href="#L366">366</a><a id="L367" href="#L367">367</a><a id="L368" href="#L368">368</a><a id="L369" href="#L369">369</a><a id="L370" href="#L370">370</a><a id="L371" href="#L371">371</a><a id="L372" href="#L372">372</a><a id="L373" href="#L373">373</a><a id="L374" href="#L374">374</a><a id="L375" href="#L375">375</a><a id="L376" href="#L376">376</a><a id="L377" href="#L377">377</a><a id="L378" href="#L378">378</a><a id="L379" href="#L379">379</a><a id="L380" href="#L380">380</a><a id="L381" href="#L381">381</a><a id="L382" href="#L382">382</a><a id="L383" href="#L383">383</a><a id="L384" href="#L384">384</a><a id="L385" href="#L385">385</a><a id="L386" href="#L386">386</a><a id="L387" href="#L387">387</a><a id="L388" href="#L388">388</a><a id="L389" href="#L389">389</a><a id="L390" href="#L390">390</a><a id="L391" href="#L391">391</a><a id="L392" href="#L392">392</a><a id="L393" href="#L393">393</a><a id="L394" href="#L394">394</a><a id="L395" href="#L395">395</a><a id="L396" href="#L396">396</a><a id="L397" href="#L397">397</a><a id="L398" href="#L398">398</a><a id="L399" href="#L399">399</a><a id="L400" href="#L400">400</a><a id="L401" href="#L401">401</a><a id="L402" href="#L402">402</a><a id="L403" href="#L403">403</a><a id="L404" href="#L404">404</a><a id="L405" href="#L405">405</a><a id="L406" href="#L406">406</a><a id="L407" href="#L407">407</a><a id="L408" href="#L408">408</a><a id="L409" href="#L409">409</a><a id="L410" href="#L410">410</a><a id="L411" href="#L411">411</a><a id="L412" href="#L412">412</a><a id="L413" href="#L413">413</a><a id="L414" href="#L414">414</a><a id="L415" href="#L415">415</a><a id="L416" href="#L416">416</a><a id="L417" href="#L417">417</a><a id="L418" href="#L418">418</a><a id="L419" href="#L419">419</a><a id="L420" href="#L420">420</a><a id="L421" href="#L421">421</a><a id="L422" href="#L422">422</a><a id="L423" href="#L423">423</a><a id="L424" href="#L424">424</a><a id="L425" href="#L425">425</a><a id="L426" href="#L426">426</a><a id="L427" href="#L427">427</a><a id="L428" href="#L428">428</a><a id="L429" href="#L429">429</a><a id="L430" href="#L430">430</a><a id="L431" href="#L431">431</a><a id="L432" href="#L432">432</a><a id="L433" href="#L433">433</a><a id="L434" href="#L434">434</a><a id="L435" href="#L435">435</a><a id="L436" href="#L436">436</a><a id="L437" href="#L437">437</a><a id="L438" href="#L438">438</a><a id="L439" href="#L439">439</a><a id="L440" href="#L440">440</a><a id="L441" href="#L441">441</a><a id="L442" href="#L442">442</a><a id="L443" href="#L443">443</a><a id="L444" href="#L444">444</a><a id="L445" href="#L445">445</a><a id="L446" href="#L446">446</a><a id="L447" href="#L447">447</a><a id="L448" href="#L448">448</a><a id="L449" href="#L449">449</a><a id="L450" href="#L450">450</a><a id="L451" href="#L451">451</a><a id="L452" href="#L452">452</a><a id="L453" href="#L453">453</a><a id="L454" href="#L454">454</a><a id="L455" href="#L455">455</a><a id="L456" href="#L456">456</a><a id="L457" href="#L457">457</a><a id="L458" href="#L458">458</a><a id="L459" href="#L459">459</a><a id="L460" href="#L460">460</a><a id="L461" href="#L461">461</a><a id="L462" href="#L462">462</a><a id="L463" href="#L463">463</a><a id="L464" href="#L464">464</a><a id="L465" href="#L465">465</a><a id="L466" href="#L466">466</a><a id="L467" href="#L467">467</a><a id="L468" href="#L468">468</a><a id="L469" href="#L469">469</a><a id="L470" href="#L470">470</a><a id="L471" href="#L471">471</a><a id="L472" href="#L472">472</a><a id="L473" href="#L473">473</a><a id="L474" href="#L474">474</a><a id="L475" href="#L475">475</a><a id="L476" href="#L476">476</a><a id="L477" href="#L477">477</a><a id="L478" href="#L478">478</a><a id="L479" href="#L479">479</a><a id="L480" href="#L480">480</a><a id="L481" href="#L481">481</a><a id="L482" href="#L482">482</a><a id="L483" href="#L483">483</a><a id="L484" href="#L484">484</a><a id="L485" href="#L485">485</a><a id="L486" href="#L486">486</a><a id="L487" href="#L487">487</a><a id="L488" href="#L488">488</a><a id="L489" href="#L489">489</a><a id="L490" href="#L490">490</a><a id="L491" href="#L491">491</a><a id="L492" href="#L492">492</a><a id="L493" href="#L493">493</a><a id="L494" href="#L494">494</a><a id="L495" href="#L495">495</a><a id="L496" href="#L496">496</a><a id="L497" href="#L497">497</a><a id="L498" href="#L498">498</a><a id="L499" href="#L499">499</a><a id="L500" href="#L500">500</a><a id="L501" href="#L501">501</a><a id="L502" href="#L502">502</a><a id="L503" href="#L503">503</a><a id="L504" href="#L504">504</a><a id="L505" href="#L505">505</a><a id="L506" href="#L506">506</a><a id="L507" href="#L507">507</a><a id="L508" href="#L508">508</a><a id="L509" href="#L509">509</a><a id="L510" href="#L510">510</a><a id="L511" href="#L511">511</a><a id="L512" href="#L512">512</a><a id="L513" href="#L513">513</a><a id="L514" href="#L514">514</a><a id="L515" href="#L515">515</a><a id="L516" href="#L516">516</a><a id="L517" href="#L517">517</a><a id="L518" href="#L518">518</a><a id="L519" href="#L519">519</a><a id="L520" href="#L520">520</a><a id="L521" href="#L521">521</a><a id="L522" href="#L522">522</a><a id="L523" href="#L523">523</a><a id="L524" href="#L524">524</a><a id="L525" href="#L525">525</a><a id="L526" href="#L526">526</a><a id="L527" href="#L527">527</a><a id="L528" href="#L528">528</a><a id="L529" href="#L529">529</a><a id="L530" href="#L530">530</a><a id="L531" href="#L531">531</a><a id="L532" href="#L532">532</a><a id="L533" href="#L533">533</a><a id="L534" href="#L534">534</a><a id="L535" href="#L535">535</a><a id="L536" href="#L536">536</a><a id="L537" href="#L537">537</a><a id="L538" href="#L538">538</a><a id="L539" href="#L539">539</a><a id="L540" href="#L540">540</a><a id="L541" href="#L541">541</a><a id="L542" href="#L542">542</a><a id="L543" href="#L543">543</a><a id="L544" href="#L544">544</a><a id="L545" href="#L545">545</a><a id="L546" href="#L546">546</a><a id="L547" href="#L547">547</a><a id="L548" href="#L548">548</a><a id="L549" href="#L549">549</a><a id="L550" href="#L550">550</a><a id="L551" href="#L551">551</a><a id="L552" href="#L552">552</a><a id="L553" href="#L553">553</a><a id="L554" href="#L554">554</a><a id="L555" href="#L555">555</a><a id="L556" href="#L556">556</a><a id="L557" href="#L557">557</a><a id="L558" href="#L558">558</a><a id="L559" href="#L559">559</a><a id="L560" href="#L560">560</a><a id="L561" href="#L561">561</a><a id="L562" href="#L562">562</a><a id="L563" href="#L563">563</a><a id="L564" href="#L564">564</a><a id="L565" href="#L565">565</a><a id="L566" href="#L566">566</a><a id="L567" href="#L567">567</a><a id="L568" href="#L568">568</a><a id="L569" href="#L569">569</a><a id="L570" href="#L570">570</a><a id="L571" href="#L571">571</a><a id="L572" href="#L572">572</a><a id="L573" href="#L573">573</a><a id="L574" href="#L574">574</a><a id="L575" href="#L575">575</a><a id="L576" href="#L576">576</a><a id="L577" href="#L577">577</a><a id="L578" href="#L578">578</a><a id="L579" href="#L579">579</a><a id="L580" href="#L580">580</a><a id="L581" href="#L581">581</a><a id="L582" href="#L582">582</a><a id="L583" href="#L583">583</a><a id="L584" href="#L584">584</a><a id="L585" href="#L585">585</a><a id="L586" href="#L586">586</a><a id="L587" href="#L587">587</a><a id="L588" href="#L588">588</a><a id="L589" href="#L589">589</a><a id="L590" href="#L590">590</a><a id="L591" href="#L591">591</a><a id="L592" href="#L592">592</a><a id="L593" href="#L593">593</a><a id="L594" href="#L594">594</a><a id="L595" href="#L595">595</a><a id="L596" href="#L596">596</a><a id="L597" href="#L597">597</a><a id="L598" href="#L598">598</a><a id="L599" href="#L599">599</a><a id="L600" href="#L600">600</a><a id="L601" href="#L601">601</a><a id="L602" href="#L602">602</a><a id="L603" href="#L603">603</a><a id="L604" href="#L604">604</a><a id="L605" href="#L605">605</a><a id="L606" href="#L606">606</a><a id="L607" href="#L607">607</a><a id="L608" href="#L608">608</a><a id="L609" href="#L609">609</a><a id="L610" href="#L610">610</a><a id="L611" href="#L611">611</a><a id="L612" href="#L612">612</a><a id="L613" href="#L613">613</a><a id="L614" href="#L614">614</a><a id="L615" href="#L615">615</a><a id="L616" href="#L616">616</a><a id="L617" href="#L617">617</a><a id="L618" href="#L618">618</a><a id="L619" href="#L619">619</a><a id="L620" href="#L620">620</a><a id="L621" href="#L621">621</a><a id="L622" href="#L622">622</a><a id="L623" href="#L623">623</a><a id="L624" href="#L624">624</a><a id="L625" href="#L625">625</a><a id="L626" href="#L626">626</a><a id="L627" href="#L627">627</a><a id="L628" href="#L628">628</a><a id="L629" href="#L629">629</a><a id="L630" href="#L630">630</a><a id="L631" href="#L631">631</a><a id="L632" href="#L632">632</a><a id="L633" href="#L633">633</a><a id="L634" href="#L634">634</a><a id="L635" href="#L635">635</a><a id="L636" href="#L636">636</a><a id="L637" href="#L637">637</a><a id="L638" href="#L638">638</a><a id="L639" href="#L639">639</a><a id="L640" href="#L640">640</a><a id="L641" href="#L641">641</a><a id="L642" href="#L642">642</a><a id="L643" href="#L643">643</a><a id="L644" href="#L644">644</a><a id="L645" href="#L645">645</a><a id="L646" href="#L646">646</a><a id="L647" href="#L647">647</a><a id="L648" href="#L648">648</a><a id="L649" href="#L649">649</a><a id="L650" href="#L650">650</a><a id="L651" href="#L651">651</a><a id="L652" href="#L652">652</a><a id="L653" href="#L653">653</a><a id="L654" href="#L654">654</a><a id="L655" href="#L655">655</a><a id="L656" href="#L656">656</a><a id="L657" href="#L657">657</a><a id="L658" href="#L658">658</a><a id="L659" href="#L659">659</a><a id="L660" href="#L660">660</a><a id="L661" href="#L661">661</a><a id="L662" href="#L662">662</a><a id="L663" href="#L663">663</a><a id="L664" href="#L664">664</a><a id="L665" href="#L665">665</a><a id="L666" href="#L666">666</a><a id="L667" href="#L667">667</a><a id="L668" href="#L668">668</a><a id="L669" href="#L669">669</a><a id="L670" href="#L670">670</a><a id="L671" href="#L671">671</a><a id="L672" href="#L672">672</a><a id="L673" href="#L673">673</a><a id="L674" href="#L674">674</a><a id="L675" href="#L675">675</a><a id="L676" href="#L676">676</a><a id="L677" href="#L677">677</a><a id="L678" href="#L678">678</a><a id="L679" href="#L679">679</a><a id="L680" href="#L680">680</a><a id="L681" href="#L681">681</a><a id="L682" href="#L682">682</a><a id="L683" href="#L683">683</a><a id="L684" href="#L684">684</a><a id="L685" href="#L685">685</a><a id="L686" href="#L686">686</a><a id="L687" href="#L687">687</a><a id="L688" href="#L688">688</a><a id="L689" href="#L689">689</a><a id="L690" href="#L690">690</a><a id="L691" href="#L691">691</a><a id="L692" href="#L692">692</a><a id="L693" href="#L693">693</a><a id="L694" href="#L694">694</a><a id="L695" href="#L695">695</a><a id="L696" href="#L696">696</a><a id="L697" href="#L697">697</a><a id="L698" href="#L698">698</a><a id="L699" href="#L699">699</a><a id="L700" href="#L700">700</a><a id="L701" href="#L701">701</a><a id="L702" href="#L702">702</a><a id="L703" href="#L703">703</a><a id="L704" href="#L704">704</a><a id="L705" href="#L705">705</a><a id="L706" href="#L706">706</a><a id="L707" href="#L707">707</a><a id="L708" href="#L708">708</a><a id="L709" href="#L709">709</a><a id="L710" href="#L710">710</a><a id="L711" href="#L711">711</a><a id="L712" href="#L712">712</a><a id="L713" href="#L713">713</a><a id="L714" href="#L714">714</a><a id="L715" href="#L715">715</a><a id="L716" href="#L716">716</a><a id="L717" href="#L717">717</a><a id="L718" href="#L718">718</a><a id="L719" href="#L719">719</a><a id="L720" href="#L720">720</a><a id="L721" href="#L721">721</a><a id="L722" href="#L722">722</a><a id="L723" href="#L723">723</a><a id="L724" href="#L724">724</a><a id="L725" href="#L725">725</a><a id="L726" href="#L726">726</a><a id="L727" href="#L727">727</a><a id="L728" href="#L728">728</a><a id="L729" href="#L729">729</a><a id="L730" href="#L730">730</a><a id="L731" href="#L731">731</a><a id="L732" href="#L732">732</a><a id="L733" href="#L733">733</a><a id="L734" href="#L734">734</a><a id="L735" href="#L735">735</a><a id="L736" href="#L736">736</a><a id="L737" href="#L737">737</a><a id="L738" href="#L738">738</a><a id="L739" href="#L739">739</a><a id="L740" href="#L740">740</a><a id="L741" href="#L741">741</a><a id="L742" href="#L742">742</a><a id="L743" href="#L743">743</a><a id="L744" href="#L744">744</a><a id="L745" href="#L745">745</a><a id="L746" href="#L746">746</a><a id="L747" href="#L747">747</a><a id="L748" href="#L748">748</a><a id="L749" href="#L749">749</a><a id="L750" href="#L750">750</a><a id="L751" href="#L751">751</a><a id="L752" href="#L752">752</a><a id="L753" href="#L753">753</a><a id="L754" href="#L754">754</a><a id="L755" href="#L755">755</a><a id="L756" href="#L756">756</a><a id="L757" href="#L757">757</a><a id="L758" href="#L758">758</a><a id="L759" href="#L759">759</a><a id="L760" href="#L760">760</a><a id="L761" href="#L761">761</a><a id="L762" href="#L762">762</a><a id="L763" href="#L763">763</a><a id="L764" href="#L764">764</a><a id="L765" href="#L765">765</a><a id="L766" href="#L766">766</a><a id="L767" href="#L767">767</a><a id="L768" href="#L768">768</a><a id="L769" href="#L769">769</a><a id="L770" href="#L770">770</a><a id="L771" href="#L771">771</a><a id="L772" href="#L772">772</a><a id="L773" href="#L773">773</a><a id="L774" href="#L774">774</a><a id="L775" href="#L775">775</a><a id="L776" href="#L776">776</a><a id="L777" href="#L777">777</a><a id="L778" href="#L778">778</a><a id="L779" href="#L779">779</a><a id="L780" href="#L780">780</a><a id="L781" href="#L781">781</a><a id="L782" href="#L782">782</a><a id="L783" href="#L783">783</a><a id="L784" href="#L784">784</a><a id="L785" href="#L785">785</a><a id="L786" href="#L786">786</a><a id="L787" href="#L787">787</a><a id="L788" href="#L788">788</a><a id="L789" href="#L789">789</a><a id="L790" href="#L790">790</a><a id="L791" href="#L791">791</a><a id="L792" href="#L792">792</a><a id="L793" href="#L793">793</a><a id="L794" href="#L794">794</a><a id="L795" href="#L795">795</a><a id="L796" href="#L796">796</a><a id="L797" href="#L797">797</a><a id="L798" href="#L798">798</a><a id="L799" href="#L799">799</a><a id="L800" href="#L800">800</a><a id="L801" href="#L801">801</a><a id="L802" href="#L802">802</a><a id="L803" href="#L803">803</a><a id="L804" href="#L804">804</a><a id="L805" href="#L805">805</a><a id="L806" href="#L806">806</a><a id="L807" href="#L807">807</a><a id="L808" href="#L808">808</a><a id="L809" href="#L809">809</a><a id="L810" href="#L810">810</a><a id="L811" href="#L811">811</a><a id="L812" href="#L812">812</a><a id="L813" href="#L813">813</a><a id="L814" href="#L814">814</a><a id="L815" href="#L815">815</a><a id="L816" href="#L816">816</a><a id="L817" href="#L817">817</a><a id="L818" href="#L818">818</a><a id="L819" href="#L819">819</a><a id="L820" href="#L820">820</a><a id="L821" href="#L821">821</a><a id="L822" href="#L822">822</a><a id="L823" href="#L823">823</a><a id="L824" href="#L824">824</a><a id="L825" href="#L825">825</a><a id="L826" href="#L826">826</a><a id="L827" href="#L827">827</a><a id="L828" href="#L828">828</a><a id="L829" href="#L829">829</a><a id="L830" href="#L830">830</a><a id="L831" href="#L831">831</a><a id="L832" href="#L832">832</a><a id="L833" href="#L833">833</a><a id="L834" href="#L834">834</a><a id="L835" href="#L835">835</a><a id="L836" href="#L836">836</a><a id="L837" href="#L837">837</a><a id="L838" href="#L838">838</a><a id="L839" href="#L839">839</a><a id="L840" href="#L840">840</a><a id="L841" href="#L841">841</a><a id="L842" href="#L842">842</a><a id="L843" href="#L843">843</a><a id="L844" href="#L844">844</a><a id="L845" href="#L845">845</a><a id="L846" href="#L846">846</a><a id="L847" href="#L847">847</a><a id="L848" href="#L848">848</a><a id="L849" href="#L849">849</a><a id="L850" href="#L850">850</a><a id="L851" href="#L851">851</a><a id="L852" href="#L852">852</a><a id="L853" href="#L853">853</a><a id="L854" href="#L854">854</a><a id="L855" href="#L855">855</a><a id="L856" href="#L856">856</a><a id="L857" href="#L857">857</a><a id="L858" href="#L858">858</a><a id="L859" href="#L859">859</a><a id="L860" href="#L860">860</a><a id="L861" href="#L861">861</a><a id="L862" href="#L862">862</a><a id="L863" href="#L863">863</a><a id="L864" href="#L864">864</a><a id="L865" href="#L865">865</a><a id="L866" href="#L866">866</a><a id="L867" href="#L867">867</a><a id="L868" href="#L868">868</a><a id="L869" href="#L869">869</a><a id="L870" href="#L870">870</a><a id="L871" href="#L871">871</a><a id="L872" href="#L872">872</a><a id="L873" href="#L873">873</a><a id="L874" href="#L874">874</a><a id="L875" href="#L875">875</a><a id="L876" href="#L876">876</a><a id="L877" href="#L877">877</a><a id="L878" href="#L878">878</a><a id="L879" href="#L879">879</a><a id="L880" href="#L880">880</a><a id="L881" href="#L881">881</a><a id="L882" href="#L882">882</a><a id="L883" href="#L883">883</a><a id="L884" href="#L884">884</a><a id="L885" href="#L885">885</a><a id="L886" href="#L886">886</a><a id="L887" href="#L887">887</a><a id="L888" href="#L888">888</a><a id="L889" href="#L889">889</a><a id="L890" href="#L890">890</a><a id="L891" href="#L891">891</a><a id="L892" href="#L892">892</a><a id="L893" href="#L893">893</a><a id="L894" href="#L894">894</a><a id="L895" href="#L895">895</a><a id="L896" href="#L896">896</a><a id="L897" href="#L897">897</a><a id="L898" href="#L898">898</a><a id="L899" href="#L899">899</a><a id="L900" href="#L900">900</a><a id="L901" href="#L901">901</a><a id="L902" href="#L902">902</a><a id="L903" href="#L903">903</a><a id="L904" href="#L904">904</a><a id="L905" href="#L905">905</a><a id="L906" href="#L906">906</a><a id="L907" href="#L907">907</a><a id="L908" href="#L908">908</a><a id="L909" href="#L909">909</a><a id="L910" href="#L910">910</a><a id="L911" href="#L911">911</a><a id="L912" href="#L912">912</a><a id="L913" href="#L913">913</a><a id="L914" href="#L914">914</a><a id="L915" href="#L915">915</a><a id="L916" href="#L916">916</a><a id="L917" href="#L917">917</a><a id="L918" href="#L918">918</a><a id="L919" href="#L919">919</a><a id="L920" href="#L920">920</a><a id="L921" href="#L921">921</a><a id="L922" href="#L922">922</a><a id="L923" href="#L923">923</a><a id="L924" href="#L924">924</a><a id="L925" href="#L925">925</a><a id="L926" href="#L926">926</a><a id="L927" href="#L927">927</a><a id="L928" href="#L928">928</a><a id="L929" href="#L929">929</a><a id="L930" href="#L930">930</a><a id="L931" href="#L931">931</a><a id="L932" href="#L932">932</a><a id="L933" href="#L933">933</a><a id="L934" href="#L934">934</a><a id="L935" href="#L935">935</a><a id="L936" href="#L936">936</a><a id="L937" href="#L937">937</a><a id="L938" href="#L938">938</a><a id="L939" href="#L939">939</a><a id="L940" href="#L940">940</a><a id="L941" href="#L941">941</a><a id="L942" href="#L942">942</a><a id="L943" href="#L943">943</a><a id="L944" href="#L944">944</a><a id="L945" href="#L945">945</a><a id="L946" href="#L946">946</a><a id="L947" href="#L947">947</a><a id="L948" href="#L948">948</a><a id="L949" href="#L949">949</a><a id="L950" href="#L950">950</a><a id="L951" href="#L951">951</a><a id="L952" href="#L952">952</a><a id="L953" href="#L953">953</a><a id="L954" href="#L954">954</a><a id="L955" href="#L955">955</a><a id="L956" href="#L956">956</a><a id="L957" href="#L957">957</a><a id="L958" href="#L958">958</a><a id="L959" href="#L959">959</a><a id="L960" href="#L960">960</a><a id="L961" href="#L961">961</a><a id="L962" href="#L962">962</a><a id="L963" href="#L963">963</a><a id="L964" href="#L964">964</a><a id="L965" href="#L965">965</a><a id="L966" href="#L966">966</a><a id="L967" href="#L967">967</a><a id="L968" href="#L968">968</a><a id="L969" href="#L969">969</a><a id="L970" href="#L970">970</a><a id="L971" href="#L971">971</a><a id="L972" href="#L972">972</a><a id="L973" href="#L973">973</a><a id="L974" href="#L974">974</a><a id="L975" href="#L975">975</a><a id="L976" href="#L976">976</a><a id="L977" href="#L977">977</a><a id="L978" href="#L978">978</a><a id="L979" href="#L979">979</a><a id="L980" href="#L980">980</a><a id="L981" href="#L981">981</a><a id="L982" href="#L982">982</a><a id="L983" href="#L983">983</a><a id="L984" href="#L984">984</a><a id="L985" href="#L985">985</a><a id="L986" href="#L986">986</a><a id="L987" href="#L987">987</a><a id="L988" href="#L988">988</a><a id="L989" href="#L989">989</a><a id="L990" href="#L990">990</a><a id="L991" href="#L991">991</a><a id="L992" href="#L992">992</a><a id="L993" href="#L993">993</a><a id="L994" href="#L994">994</a><a id="L995" href="#L995">995</a><a id="L996" href="#L996">996</a><a id="L997" href="#L997">997</a><a id="L998" href="#L998">998</a><a id="L999" href="#L999">999</a><a id="L1000" href="#L1000">1000</a><a id="L1001" href="#L1001">1001</a><a id="L1002" href="#L1002">1002</a><a id="L1003" href="#L1003">1003</a><a id="L1004" href="#L1004">1004</a><a id="L1005" href="#L1005">1005</a><a id="L1006" href="#L1006">1006</a><a id="L1007" href="#L1007">1007</a><a id="L1008" href="#L1008">1008</a><a id="L1009" href="#L1009">1009</a><a id="L1010" href="#L1010">1010</a><a id="L1011" href="#L1011">1011</a><a id="L1012" href="#L1012">1012</a><a id="L1013" href="#L1013">1013</a><a id="L1014" href="#L1014">1014</a><a id="L1015" href="#L1015">1015</a><a id="L1016" href="#L1016">1016</a><a id="L1017" href="#L1017">1017</a><a id="L1018" href="#L1018">1018</a><a id="L1019" href="#L1019">1019</a><a id="L1020" href="#L1020">1020</a><a id="L1021" href="#L1021">1021</a><a id="L1022" href="#L1022">1022</a><a id="L1023" href="#L1023">1023</a><a id="L1024" href="#L1024">1024</a><a id="L1025" href="#L1025">1025</a><a id="L1026" href="#L1026">1026</a><a id="L1027" href="#L1027">1027</a><a id="L1028" href="#L1028">1028</a><a id="L1029" href="#L1029">1029</a><a id="L1030" href="#L1030">1030</a><a id="L1031" href="#L1031">1031</a><a id="L1032" href="#L1032">1032</a><a id="L1033" href="#L1033">1033</a><a id="L1034" href="#L1034">1034</a><a id="L1035" href="#L1035">1035</a><a id="L1036" href="#L1036">1036</a><a id="L1037" href="#L1037">1037</a><a id="L1038" href="#L1038">1038</a><a id="L1039" href="#L1039">1039</a><a id="L1040" href="#L1040">1040</a><a id="L1041" href="#L1041">1041</a><a id="L1042" href="#L1042">1042</a><a id="L1043" href="#L1043">1043</a><a id="L1044" href="#L1044">1044</a><a id="L1045" href="#L1045">1045</a><a id="L1046" href="#L1046">1046</a><a id="L1047" href="#L1047">1047</a><a id="L1048" href="#L1048">1048</a><a id="L1049" href="#L1049">1049</a><a id="L1050" href="#L1050">1050</a><a id="L1051" href="#L1051">1051</a><a id="L1052" href="#L1052">1052</a><a id="L1053" href="#L1053">1053</a><a id="L1054" href="#L1054">1054</a><a id="L1055" href="#L1055">1055</a><a id="L1056" href="#L1056">1056</a><a id="L1057" href="#L1057">1057</a><a id="L1058" href="#L1058">1058</a><a id="L1059" href="#L1059">1059</a><a id="L1060" href="#L1060">1060</a><a id="L1061" href="#L1061">1061</a><a id="L1062" href="#L1062">1062</a><a id="L1063" href="#L1063">1063</a><a id="L1064" href="#L1064">1064</a><a id="L1065" href="#L1065">1065</a><a id="L1066" href="#L1066">1066</a><a id="L1067" href="#L1067">1067</a><a id="L1068" href="#L1068">1068</a><a id="L1069" href="#L1069">1069</a><a id="L1070" href="#L1070">1070</a><a id="L1071" href="#L1071">1071</a><a id="L1072" href="#L1072">1072</a><a id="L1073" href="#L1073">1073</a><a id="L1074" href="#L1074">1074</a><a id="L1075" href="#L1075">1075</a><a id="L1076" href="#L1076">1076</a><a id="L1077" href="#L1077">1077</a><a id="L1078" href="#L1078">1078</a><a id="L1079" href="#L1079">1079</a><a id="L1080" href="#L1080">1080</a><a id="L1081" href="#L1081">1081</a><a id="L1082" href="#L1082">1082</a><a id="L1083" href="#L1083">1083</a><a id="L1084" href="#L1084">1084</a><a id="L1085" href="#L1085">1085</a><a id="L1086" href="#L1086">1086</a><a id="L1087" href="#L1087">1087</a><a id="L1088" href="#L1088">1088</a><a id="L1089" href="#L1089">1089</a><a id="L1090" href="#L1090">1090</a><a id="L1091" href="#L1091">1091</a><a id="L1092" href="#L1092">1092</a><a id="L1093" href="#L1093">1093</a><a id="L1094" href="#L1094">1094</a><a id="L1095" href="#L1095">1095</a><a id="L1096" href="#L1096">1096</a><a id="L1097" href="#L1097">1097</a><a id="L1098" href="#L1098">1098</a><a id="L1099" href="#L1099">1099</a><a id="L1100" href="#L1100">1100</a><a id="L1101" href="#L1101">1101</a><a id="L1102" href="#L1102">1102</a><a id="L1103" href="#L1103">1103</a><a id="L1104" href="#L1104">1104</a><a id="L1105" href="#L1105">1105</a><a id="L1106" href="#L1106">1106</a><a id="L1107" href="#L1107">1107</a><a id="L1108" href="#L1108">1108</a><a id="L1109" href="#L1109">1109</a><a id="L1110" href="#L1110">1110</a><a id="L1111" href="#L1111">1111</a><a id="L1112" href="#L1112">1112</a><a id="L1113" href="#L1113">1113</a><a id="L1114" href="#L1114">1114</a><a id="L1115" href="#L1115">1115</a><a id="L1116" href="#L1116">1116</a><a id="L1117" href="#L1117">1117</a><a id="L1118" href="#L1118">1118</a><a id="L1119" href="#L1119">1119</a><a id="L1120" href="#L1120">1120</a><a id="L1121" href="#L1121">1121</a><a id="L1122" href="#L1122">1122</a><a id="L1123" href="#L1123">1123</a><a id="L1124" href="#L1124">1124</a><a id="L1125" href="#L1125">1125</a><a id="L1126" href="#L1126">1126</a><a id="L1127" href="#L1127">1127</a><a id="L1128" href="#L1128">1128</a><a id="L1129" href="#L1129">1129</a><a id="L1130" href="#L1130">1130</a><a id="L1131" href="#L1131">1131</a><a id="L1132" href="#L1132">1132</a><a id="L1133" href="#L1133">1133</a><a id="L1134" href="#L1134">1134</a><a id="L1135" href="#L1135">1135</a><a id="L1136" href="#L1136">1136</a><a id="L1137" href="#L1137">1137</a><a id="L1138" href="#L1138">1138</a><a id="L1139" href="#L1139">1139</a><a id="L1140" href="#L1140">1140</a><a id="L1141" href="#L1141">1141</a><a id="L1142" href="#L1142">1142</a><a id="L1143" href="#L1143">1143</a><a id="L1144" href="#L1144">1144</a><a id="L1145" href="#L1145">1145</a><a id="L1146" href="#L1146">1146</a><a id="L1147" href="#L1147">1147</a><a id="L1148" href="#L1148">1148</a><a id="L1149" href="#L1149">1149</a><a id="L1150" href="#L1150">1150</a><a id="L1151" href="#L1151">1151</a><a id="L1152" href="#L1152">1152</a><a id="L1153" href="#L1153">1153</a><a id="L1154" href="#L1154">1154</a><a id="L1155" href="#L1155">1155</a><a id="L1156" href="#L1156">1156</a><a id="L1157" href="#L1157">1157</a><a id="L1158" href="#L1158">1158</a><a id="L1159" href="#L1159">1159</a><a id="L1160" href="#L1160">1160</a><a id="L1161" href="#L1161">1161</a><a id="L1162" href="#L1162">1162</a><a id="L1163" href="#L1163">1163</a><a id="L1164" href="#L1164">1164</a><a id="L1165" href="#L1165">1165</a><a id="L1166" href="#L1166">1166</a><a id="L1167" href="#L1167">1167</a><a id="L1168" href="#L1168">1168</a><a id="L1169" href="#L1169">1169</a><a id="L1170" href="#L1170">1170</a><a id="L1171" href="#L1171">1171</a><a id="L1172" href="#L1172">1172</a><a id="L1173" href="#L1173">1173</a><a id="L1174" href="#L1174">1174</a><a id="L1175" href="#L1175">1175</a><a id="L1176" href="#L1176">1176</a><a id="L1177" href="#L1177">1177</a><a id="L1178" href="#L1178">1178</a><a id="L1179" href="#L1179">1179</a><a id="L1180" href="#L1180">1180</a><a id="L1181" href="#L1181">1181</a><a id="L1182" href="#L1182">1182</a><a id="L1183" href="#L1183">1183</a><a id="L1184" href="#L1184">1184</a><a id="L1185" href="#L1185">1185</a><a id="L1186" href="#L1186">1186</a><a id="L1187" href="#L1187">1187</a><a id="L1188" href="#L1188">1188</a><a id="L1189" href="#L1189">1189</a><a id="L1190" href="#L1190">1190</a><a id="L1191" href="#L1191">1191</a><a id="L1192" href="#L1192">1192</a><a id="L1193" href="#L1193">1193</a><a id="L1194" href="#L1194">1194</a><a id="L1195" href="#L1195">1195</a><a id="L1196" href="#L1196">1196</a><a id="L1197" href="#L1197">1197</a><a id="L1198" href="#L1198">1198</a><a id="L1199" href="#L1199">1199</a><a id="L1200" href="#L1200">1200</a><a id="L1201" href="#L1201">1201</a><a id="L1202" href="#L1202">1202</a><a id="L1203" href="#L1203">1203</a><a id="L1204" href="#L1204">1204</a><a id="L1205" href="#L1205">1205</a><a id="L1206" href="#L1206">1206</a><a id="L1207" href="#L1207">1207</a><a id="L1208" href="#L1208">1208</a><a id="L1209" href="#L1209">1209</a><a id="L1210" href="#L1210">1210</a><a id="L1211" href="#L1211">1211</a><a id="L1212" href="#L1212">1212</a><a id="L1213" href="#L1213">1213</a><a id="L1214" href="#L1214">1214</a><a id="L1215" href="#L1215">1215</a><a id="L1216" href="#L1216">1216</a><a id="L1217" href="#L1217">1217</a><a id="L1218" href="#L1218">1218</a><a id="L1219" href="#L1219">1219</a><a id="L1220" href="#L1220">1220</a><a id="L1221" href="#L1221">1221</a><a id="L1222" href="#L1222">1222</a><a id="L1223" href="#L1223">1223</a><a id="L1224" href="#L1224">1224</a><a id="L1225" href="#L1225">1225</a><a id="L1226" href="#L1226">1226</a><a id="L1227" href="#L1227">1227</a><a id="L1228" href="#L1228">1228</a><a id="L1229" href="#L1229">1229</a><a id="L1230" href="#L1230">1230</a><a id="L1231" href="#L1231">1231</a><a id="L1232" href="#L1232">1232</a><a id="L1233" href="#L1233">1233</a><a id="L1234" href="#L1234">1234</a><a id="L1235" href="#L1235">1235</a><a id="L1236" href="#L1236">1236</a><a id="L1237" href="#L1237">1237</a><a id="L1238" href="#L1238">1238</a><a id="L1239" href="#L1239">1239</a><a id="L1240" href="#L1240">1240</a><a id="L1241" href="#L1241">1241</a><a id="L1242" href="#L1242">1242</a><a id="L1243" href="#L1243">1243</a><a id="L1244" href="#L1244">1244</a><a id="L1245" href="#L1245">1245</a><a id="L1246" href="#L1246">1246</a><a id="L1247" href="#L1247">1247</a><a id="L1248" href="#L1248">1248</a><a id="L1249" href="#L1249">1249</a><a id="L1250" href="#L1250">1250</a><a id="L1251" href="#L1251">1251</a><a id="L1252" href="#L1252">1252</a><a id="L1253" href="#L1253">1253</a><a id="L1254" href="#L1254">1254</a><a id="L1255" href="#L1255">1255</a><a id="L1256" href="#L1256">1256</a><a id="L1257" href="#L1257">1257</a><a id="L1258" href="#L1258">1258</a><a id="L1259" href="#L1259">1259</a><a id="L1260" href="#L1260">1260</a><a id="L1261" href="#L1261">1261</a><a id="L1262" href="#L1262">1262</a><a id="L1263" href="#L1263">1263</a><a id="L1264" href="#L1264">1264</a><a id="L1265" href="#L1265">1265</a><a id="L1266" href="#L1266">1266</a><a id="L1267" href="#L1267">1267</a><a id="L1268" href="#L1268">1268</a><a id="L1269" href="#L1269">1269</a><a id="L1270" href="#L1270">1270</a><a id="L1271" href="#L1271">1271</a><a id="L1272" href="#L1272">1272</a><a id="L1273" href="#L1273">1273</a><a id="L1274" href="#L1274">1274</a><a id="L1275" href="#L1275">1275</a><a id="L1276" href="#L1276">1276</a><a id="L1277" href="#L1277">1277</a><a id="L1278" href="#L1278">1278</a><a id="L1279" href="#L1279">1279</a><a id="L1280" href="#L1280">1280</a><a id="L1281" href="#L1281">1281</a><a id="L1282" href="#L1282">1282</a><a id="L1283" href="#L1283">1283</a><a id="L1284" href="#L1284">1284</a><a id="L1285" href="#L1285">1285</a><a id="L1286" href="#L1286">1286</a><a id="L1287" href="#L1287">1287</a><a id="L1288" href="#L1288">1288</a><a id="L1289" href="#L1289">1289</a><a id="L1290" href="#L1290">1290</a><a id="L1291" href="#L1291">1291</a><a id="L1292" href="#L1292">1292</a><a id="L1293" href="#L1293">1293</a><a id="L1294" href="#L1294">1294</a><a id="L1295" href="#L1295">1295</a><a id="L1296" href="#L1296">1296</a><a id="L1297" href="#L1297">1297</a><a id="L1298" href="#L1298">1298</a><a id="L1299" href="#L1299">1299</a><a id="L1300" href="#L1300">1300</a><a id="L1301" href="#L1301">1301</a><a id="L1302" href="#L1302">1302</a><a id="L1303" href="#L1303">1303</a><a id="L1304" href="#L1304">1304</a><a id="L1305" href="#L1305">1305</a><a id="L1306" href="#L1306">1306</a><a id="L1307" href="#L1307">1307</a><a id="L1308" href="#L1308">1308</a><a id="L1309" href="#L1309">1309</a><a id="L1310" href="#L1310">1310</a><a id="L1311" href="#L1311">1311</a><a id="L1312" href="#L1312">1312</a><a id="L1313" href="#L1313">1313</a><a id="L1314" href="#L1314">1314</a><a id="L1315" href="#L1315">1315</a><a id="L1316" href="#L1316">1316</a><a id="L1317" href="#L1317">1317</a><a id="L1318" href="#L1318">1318</a><a id="L1319" href="#L1319">1319</a><a id="L1320" href="#L1320">1320</a><a id="L1321" href="#L1321">1321</a><a id="L1322" href="#L1322">1322</a><a id="L1323" href="#L1323">1323</a><a id="L1324" href="#L1324">1324</a><a id="L1325" href="#L1325">1325</a><a id="L1326" href="#L1326">1326</a><a id="L1327" href="#L1327">1327</a><a id="L1328" href="#L1328">1328</a><a id="L1329" href="#L1329">1329</a><a id="L1330" href="#L1330">1330</a><a id="L1331" href="#L1331">1331</a><a id="L1332" href="#L1332">1332</a><a id="L1333" href="#L1333">1333</a><a id="L1334" href="#L1334">1334</a><a id="L1335" href="#L1335">1335</a><a id="L1336" href="#L1336">1336</a><a id="L1337" href="#L1337">1337</a><a id="L1338" href="#L1338">1338</a><a id="L1339" href="#L1339">1339</a><a id="L1340" href="#L1340">1340</a><a id="L1341" href="#L1341">1341</a><a id="L1342" href="#L1342">1342</a><a id="L1343" href="#L1343">1343</a><a id="L1344" href="#L1344">1344</a><a id="L1345" href="#L1345">1345</a><a id="L1346" href="#L1346">1346</a><a id="L1347" href="#L1347">1347</a><a id="L1348" href="#L1348">1348</a><a id="L1349" href="#L1349">1349</a><a id="L1350" href="#L1350">1350</a><a id="L1351" href="#L1351">1351</a><a id="L1352" href="#L1352">1352</a><a id="L1353" href="#L1353">1353</a><a id="L1354" href="#L1354">1354</a><a id="L1355" href="#L1355">1355</a><a id="L1356" href="#L1356">1356</a><a id="L1357" href="#L1357">1357</a><a id="L1358" href="#L1358">1358</a><a id="L1359" href="#L1359">1359</a><a id="L1360" href="#L1360">1360</a><a id="L1361" href="#L1361">1361</a><a id="L1362" href="#L1362">1362</a><a id="L1363" href="#L1363">1363</a><a id="L1364" href="#L1364">1364</a><a id="L1365" href="#L1365">1365</a><a id="L1366" href="#L1366">1366</a><a id="L1367" href="#L1367">1367</a><a id="L1368" href="#L1368">1368</a><a id="L1369" href="#L1369">1369</a><a id="L1370" href="#L1370">1370</a><a id="L1371" href="#L1371">1371</a><a id="L1372" href="#L1372">1372</a><a id="L1373" href="#L1373">1373</a><a id="L1374" href="#L1374">1374</a><a id="L1375" href="#L1375">1375</a><a id="L1376" href="#L1376">1376</a><a id="L1377" href="#L1377">1377</a><a id="L1378" href="#L1378">1378</a><a id="L1379" href="#L1379">1379</a><a id="L1380" href="#L1380">1380</a><a id="L1381" href="#L1381">1381</a><a id="L1382" href="#L1382">1382</a><a id="L1383" href="#L1383">1383</a><a id="L1384" href="#L1384">1384</a><a id="L1385" href="#L1385">1385</a><a id="L1386" href="#L1386">1386</a><a id="L1387" href="#L1387">1387</a><a id="L1388" href="#L1388">1388</a><a id="L1389" href="#L1389">1389</a><a id="L1390" href="#L1390">1390</a><a id="L1391" href="#L1391">1391</a><a id="L1392" href="#L1392">1392</a><a id="L1393" href="#L1393">1393</a><a id="L1394" href="#L1394">1394</a><a id="L1395" href="#L1395">1395</a><a id="L1396" href="#L1396">1396</a><a id="L1397" href="#L1397">1397</a><a id="L1398" href="#L1398">1398</a><a id="L1399" href="#L1399">1399</a><a id="L1400" href="#L1400">1400</a><a id="L1401" href="#L1401">1401</a><a id="L1402" href="#L1402">1402</a><a id="L1403" href="#L1403">1403</a><a id="L1404" href="#L1404">1404</a><a id="L1405" href="#L1405">1405</a><a id="L1406" href="#L1406">1406</a><a id="L1407" href="#L1407">1407</a><a id="L1408" href="#L1408">1408</a><a id="L1409" href="#L1409">1409</a><a id="L1410" href="#L1410">1410</a><a id="L1411" href="#L1411">1411</a><a id="L1412" href="#L1412">1412</a><a id="L1413" href="#L1413">1413</a><a id="L1414" href="#L1414">1414</a><a id="L1415" href="#L1415">1415</a><a id="L1416" href="#L1416">1416</a><a id="L1417" href="#L1417">1417</a><a id="L1418" href="#L1418">1418</a><a id="L1419" href="#L1419">1419</a><a id="L1420" href="#L1420">1420</a><a id="L1421" href="#L1421">1421</a><a id="L1422" href="#L1422">1422</a><a id="L1423" href="#L1423">1423</a><a id="L1424" href="#L1424">1424</a><a id="L1425" href="#L1425">1425</a><a id="L1426" href="#L1426">1426</a><a id="L1427" href="#L1427">1427</a><a id="L1428" href="#L1428">1428</a><a id="L1429" href="#L1429">1429</a><a id="L1430" href="#L1430">1430</a><a id="L1431" href="#L1431">1431</a><a id="L1432" href="#L1432">1432</a><a id="L1433" href="#L1433">1433</a><a id="L1434" href="#L1434">1434</a><a id="L1435" href="#L1435">1435</a><a id="L1436" href="#L1436">1436</a><a id="L1437" href="#L1437">1437</a><a id="L1438" href="#L1438">1438</a><a id="L1439" href="#L1439">1439</a><a id="L1440" href="#L1440">1440</a><a id="L1441" href="#L1441">1441</a><a id="L1442" href="#L1442">1442</a><a id="L1443" href="#L1443">1443</a><a id="L1444" href="#L1444">1444</a><a id="L1445" href="#L1445">1445</a><a id="L1446" href="#L1446">1446</a><a id="L1447" href="#L1447">1447</a><a id="L1448" href="#L1448">1448</a><a id="L1449" href="#L1449">1449</a><a id="L1450" href="#L1450">1450</a><a id="L1451" href="#L1451">1451</a><a id="L1452" href="#L1452">1452</a><a id="L1453" href="#L1453">1453</a><a id="L1454" href="#L1454">1454</a><a id="L1455" href="#L1455">1455</a><a id="L1456" href="#L1456">1456</a><a id="L1457" href="#L1457">1457</a><a id="L1458" href="#L1458">1458</a><a id="L1459" href="#L1459">1459</a><a id="L1460" href="#L1460">1460</a><a id="L1461" href="#L1461">1461</a><a id="L1462" href="#L1462">1462</a><a id="L1463" href="#L1463">1463</a><a id="L1464" href="#L1464">1464</a><a id="L1465" href="#L1465">1465</a><a id="L1466" href="#L1466">1466</a><a id="L1467" href="#L1467">1467</a><a id="L1468" href="#L1468">1468</a><a id="L1469" href="#L1469">1469</a><a id="L1470" href="#L1470">1470</a><a id="L1471" href="#L1471">1471</a><a id="L1472" href="#L1472">1472</a><a id="L1473" href="#L1473">1473</a><a id="L1474" href="#L1474">1474</a><a id="L1475" href="#L1475">1475</a><a id="L1476" href="#L1476">1476</a><a id="L1477" href="#L1477">1477</a><a id="L1478" href="#L1478">1478</a><a id="L1479" href="#L1479">1479</a><a id="L1480" href="#L1480">1480</a><a id="L1481" href="#L1481">1481</a><a id="L1482" href="#L1482">1482</a><a id="L1483" href="#L1483">1483</a><a id="L1484" href="#L1484">1484</a><a id="L1485" href="#L1485">1485</a><a id="L1486" href="#L1486">1486</a><a id="L1487" href="#L1487">1487</a><a id="L1488" href="#L1488">1488</a><a id="L1489" href="#L1489">1489</a><a id="L1490" href="#L1490">1490</a><a id="L1491" href="#L1491">1491</a><a id="L1492" href="#L1492">1492</a><a id="L1493" href="#L1493">1493</a><a id="L1494" href="#L1494">1494</a><a id="L1495" href="#L1495">1495</a><a id="L1496" href="#L1496">1496</a><a id="L1497" href="#L1497">1497</a><a id="L1498" href="#L1498">1498</a><a id="L1499" href="#L1499">1499</a><a id="L1500" href="#L1500">1500</a><a id="L1501" href="#L1501">1501</a><a id="L1502" href="#L1502">1502</a><a id="L1503" href="#L1503">1503</a><a id="L1504" href="#L1504">1504</a><a id="L1505" href="#L1505">1505</a><a id="L1506" href="#L1506">1506</a><a id="L1507" href="#L1507">1507</a><a id="L1508" href="#L1508">1508</a><a id="L1509" href="#L1509">1509</a><a id="L1510" href="#L1510">1510</a><a id="L1511" href="#L1511">1511</a><a id="L1512" href="#L1512">1512</a><a id="L1513" href="#L1513">1513</a><a id="L1514" href="#L1514">1514</a><a id="L1515" href="#L1515">1515</a><a id="L1516" href="#L1516">1516</a><a id="L1517" href="#L1517">1517</a><a id="L1518" href="#L1518">1518</a><a id="L1519" href="#L1519">1519</a><a id="L1520" href="#L1520">1520</a><a id="L1521" href="#L1521">1521</a><a id="L1522" href="#L1522">1522</a><a id="L1523" href="#L1523">1523</a><a id="L1524" href="#L1524">1524</a><a id="L1525" href="#L1525">1525</a><a id="L1526" href="#L1526">1526</a><a id="L1527" href="#L1527">1527</a><a id="L1528" href="#L1528">1528</a><a id="L1529" href="#L1529">1529</a><a id="L1530" href="#L1530">1530</a><a id="L1531" href="#L1531">1531</a><a id="L1532" href="#L1532">1532</a><a id="L1533" href="#L1533">1533</a><a id="L1534" href="#L1534">1534</a><a id="L1535" href="#L1535">1535</a><a id="L1536" href="#L1536">1536</a><a id="L1537" href="#L1537">1537</a><a id="L1538" href="#L1538">1538</a><a id="L1539" href="#L1539">1539</a><a id="L1540" href="#L1540">1540</a><a id="L1541" href="#L1541">1541</a><a id="L1542" href="#L1542">1542</a><a id="L1543" href="#L1543">1543</a><a id="L1544" href="#L1544">1544</a><a id="L1545" href="#L1545">1545</a><a id="L1546" href="#L1546">1546</a><a id="L1547" href="#L1547">1547</a><a id="L1548" href="#L1548">1548</a><a id="L1549" href="#L1549">1549</a><a id="L1550" href="#L1550">1550</a><a id="L1551" href="#L1551">1551</a><a id="L1552" href="#L1552">1552</a><a id="L1553" href="#L1553">1553</a><a id="L1554" href="#L1554">1554</a><a id="L1555" href="#L1555">1555</a><a id="L1556" href="#L1556">1556</a><a id="L1557" href="#L1557">1557</a><a id="L1558" href="#L1558">1558</a><a id="L1559" href="#L1559">1559</a><a id="L1560" href="#L1560">1560</a><a id="L1561" href="#L1561">1561</a><a id="L1562" href="#L1562">1562</a><a id="L1563" href="#L1563">1563</a><a id="L1564" href="#L1564">1564</a><a id="L1565" href="#L1565">1565</a><a id="L1566" href="#L1566">1566</a><a id="L1567" href="#L1567">1567</a><a id="L1568" href="#L1568">1568</a><a id="L1569" href="#L1569">1569</a><a id="L1570" href="#L1570">1570</a><a id="L1571" href="#L1571">1571</a><a id="L1572" href="#L1572">1572</a><a id="L1573" href="#L1573">1573</a><a id="L1574" href="#L1574">1574</a><a id="L1575" href="#L1575">1575</a><a id="L1576" href="#L1576">1576</a><a id="L1577" href="#L1577">1577</a><a id="L1578" href="#L1578">1578</a><a id="L1579" href="#L1579">1579</a><a id="L1580" href="#L1580">1580</a><a id="L1581" href="#L1581">1581</a><a id="L1582" href="#L1582">1582</a><a id="L1583" href="#L1583">1583</a><a id="L1584" href="#L1584">1584</a><a id="L1585" href="#L1585">1585</a><a id="L1586" href="#L1586">1586</a><a id="L1587" href="#L1587">1587</a><a id="L1588" href="#L1588">1588</a><a id="L1589" href="#L1589">1589</a><a id="L1590" href="#L1590">1590</a><a id="L1591" href="#L1591">1591</a><a id="L1592" href="#L1592">1592</a><a id="L1593" href="#L1593">1593</a><a id="L1594" href="#L1594">1594</a><a id="L1595" href="#L1595">1595</a><a id="L1596" href="#L1596">1596</a><a id="L1597" href="#L1597">1597</a><a id="L1598" href="#L1598">1598</a><a id="L1599" href="#L1599">1599</a><a id="L1600" href="#L1600">1600</a><a id="L1601" href="#L1601">1601</a><a id="L1602" href="#L1602">1602</a><a id="L1603" href="#L1603">1603</a><a id="L1604" href="#L1604">1604</a><a id="L1605" href="#L1605">1605</a><a id="L1606" href="#L1606">1606</a><a id="L1607" href="#L1607">1607</a><a id="L1608" href="#L1608">1608</a><a id="L1609" href="#L1609">1609</a><a id="L1610" href="#L1610">1610</a><a id="L1611" href="#L1611">1611</a><a id="L1612" href="#L1612">1612</a><a id="L1613" href="#L1613">1613</a><a id="L1614" href="#L1614">1614</a><a id="L1615" href="#L1615">1615</a><a id="L1616" href="#L1616">1616</a><a id="L1617" href="#L1617">1617</a><a id="L1618" href="#L1618">1618</a><a id="L1619" href="#L1619">1619</a><a id="L1620" href="#L1620">1620</a><a id="L1621" href="#L1621">1621</a><a id="L1622" href="#L1622">1622</a><a id="L1623" href="#L1623">1623</a><a id="L1624" href="#L1624">1624</a><a id="L1625" href="#L1625">1625</a><a id="L1626" href="#L1626">1626</a><a id="L1627" href="#L1627">1627</a><a id="L1628" href="#L1628">1628</a><a id="L1629" href="#L1629">1629</a><a id="L1630" href="#L1630">1630</a><a id="L1631" href="#L1631">1631</a><a id="L1632" href="#L1632">1632</a><a id="L1633" href="#L1633">1633</a><a id="L1634" href="#L1634">1634</a><a id="L1635" href="#L1635">1635</a><a id="L1636" href="#L1636">1636</a><a id="L1637" href="#L1637">1637</a><a id="L1638" href="#L1638">1638</a><a id="L1639" href="#L1639">1639</a><a id="L1640" href="#L1640">1640</a><a id="L1641" href="#L1641">1641</a><a id="L1642" href="#L1642">1642</a><a id="L1643" href="#L1643">1643</a><a id="L1644" href="#L1644">1644</a><a id="L1645" href="#L1645">1645</a><a id="L1646" href="#L1646">1646</a><a id="L1647" href="#L1647">1647</a><a id="L1648" href="#L1648">1648</a><a id="L1649" href="#L1649">1649</a><a id="L1650" href="#L1650">1650</a><a id="L1651" href="#L1651">1651</a><a id="L1652" href="#L1652">1652</a><a id="L1653" href="#L1653">1653</a><a id="L1654" href="#L1654">1654</a><a id="L1655" href="#L1655">1655</a><a id="L1656" href="#L1656">1656</a><a id="L1657" href="#L1657">1657</a><a id="L1658" href="#L1658">1658</a><a id="L1659" href="#L1659">1659</a><a id="L1660" href="#L1660">1660</a><a id="L1661" href="#L1661">1661</a><a id="L1662" href="#L1662">1662</a><a id="L1663" href="#L1663">1663</a><a id="L1664" href="#L1664">1664</a><a id="L1665" href="#L1665">1665</a><a id="L1666" href="#L1666">1666</a><a id="L1667" href="#L1667">1667</a><a id="L1668" href="#L1668">1668</a><a id="L1669" href="#L1669">1669</a><a id="L1670" href="#L1670">1670</a><a id="L1671" href="#L1671">1671</a><a id="L1672" href="#L1672">1672</a><a id="L1673" href="#L1673">1673</a><a id="L1674" href="#L1674">1674</a><a id="L1675" href="#L1675">1675</a><a id="L1676" href="#L1676">1676</a><a id="L1677" href="#L1677">1677</a><a id="L1678" href="#L1678">1678</a><a id="L1679" href="#L1679">1679</a><a id="L1680" href="#L1680">1680</a><a id="L1681" href="#L1681">1681</a><a id="L1682" href="#L1682">1682</a><a id="L1683" href="#L1683">1683</a><a id="L1684" href="#L1684">1684</a><a id="L1685" href="#L1685">1685</a><a id="L1686" href="#L1686">1686</a><a id="L1687" href="#L1687">1687</a><a id="L1688" href="#L1688">1688</a><a id="L1689" href="#L1689">1689</a><a id="L1690" href="#L1690">1690</a><a id="L1691" href="#L1691">1691</a><a id="L1692" href="#L1692">1692</a><a id="L1693" href="#L1693">1693</a><a id="L1694" href="#L1694">1694</a><a id="L1695" href="#L1695">1695</a><a id="L1696" href="#L1696">1696</a><a id="L1697" href="#L1697">1697</a><a id="L1698" href="#L1698">1698</a><a id="L1699" href="#L1699">1699</a><a id="L1700" href="#L1700">1700</a><a id="L1701" href="#L1701">1701</a><a id="L1702" href="#L1702">1702</a><a id="L1703" href="#L1703">1703</a><a id="L1704" href="#L1704">1704</a><a id="L1705" href="#L1705">1705</a><a id="L1706" href="#L1706">1706</a><a id="L1707" href="#L1707">1707</a><a id="L1708" href="#L1708">1708</a><a id="L1709" href="#L1709">1709</a><a id="L1710" href="#L1710">1710</a><a id="L1711" href="#L1711">1711</a><a id="L1712" href="#L1712">1712</a><a id="L1713" href="#L1713">1713</a><a id="L1714" href="#L1714">1714</a><a id="L1715" href="#L1715">1715</a><a id="L1716" href="#L1716">1716</a><a id="L1717" href="#L1717">1717</a><a id="L1718" href="#L1718">1718</a><a id="L1719" href="#L1719">1719</a><a id="L1720" href="#L1720">1720</a><a id="L1721" href="#L1721">1721</a><a id="L1722" href="#L1722">1722</a><a id="L1723" href="#L1723">1723</a><a id="L1724" href="#L1724">1724</a><a id="L1725" href="#L1725">1725</a><a id="L1726" href="#L1726">1726</a><a id="L1727" href="#L1727">1727</a><a id="L1728" href="#L1728">1728</a><a id="L1729" href="#L1729">1729</a><a id="L1730" href="#L1730">1730</a><a id="L1731" href="#L1731">1731</a><a id="L1732" href="#L1732">1732</a><a id="L1733" href="#L1733">1733</a><a id="L1734" href="#L1734">1734</a><a id="L1735" href="#L1735">1735</a><a id="L1736" href="#L1736">1736</a><a id="L1737" href="#L1737">1737</a><a id="L1738" href="#L1738">1738</a><a id="L1739" href="#L1739">1739</a><a id="L1740" href="#L1740">1740</a><a id="L1741" href="#L1741">1741</a><a id="L1742" href="#L1742">1742</a><a id="L1743" href="#L1743">1743</a><a id="L1744" href="#L1744">1744</a><a id="L1745" href="#L1745">1745</a><a id="L1746" href="#L1746">1746</a><a id="L1747" href="#L1747">1747</a><a id="L1748" href="#L1748">1748</a><a id="L1749" href="#L1749">1749</a><a id="L1750" href="#L1750">1750</a><a id="L1751" href="#L1751">1751</a><a id="L1752" href="#L1752">1752</a><a id="L1753" href="#L1753">1753</a><a id="L1754" href="#L1754">1754</a><a id="L1755" href="#L1755">1755</a><a id="L1756" href="#L1756">1756</a><a id="L1757" href="#L1757">1757</a><a id="L1758" href="#L1758">1758</a><a id="L1759" href="#L1759">1759</a><a id="L1760" href="#L1760">1760</a><a id="L1761" href="#L1761">1761</a><a id="L1762" href="#L1762">1762</a><a id="L1763" href="#L1763">1763</a><a id="L1764" href="#L1764">1764</a><a id="L1765" href="#L1765">1765</a><a id="L1766" href="#L1766">1766</a><a id="L1767" href="#L1767">1767</a><a id="L1768" href="#L1768">1768</a><a id="L1769" href="#L1769">1769</a><a id="L1770" href="#L1770">1770</a><a id="L1771" href="#L1771">1771</a><a id="L1772" href="#L1772">1772</a><a id="L1773" href="#L1773">1773</a><a id="L1774" href="#L1774">1774</a><a id="L1775" href="#L1775">1775</a><a id="L1776" href="#L1776">1776</a><a id="L1777" href="#L1777">1777</a><a id="L1778" href="#L1778">1778</a><a id="L1779" href="#L1779">1779</a><a id="L1780" href="#L1780">1780</a><a id="L1781" href="#L1781">1781</a><a id="L1782" href="#L1782">1782</a><a id="L1783" href="#L1783">1783</a><a id="L1784" href="#L1784">1784</a><a id="L1785" href="#L1785">1785</a><a id="L1786" href="#L1786">1786</a><a id="L1787" href="#L1787">1787</a><a id="L1788" href="#L1788">1788</a><a id="L1789" href="#L1789">1789</a><a id="L1790" href="#L1790">1790</a><a id="L1791" href="#L1791">1791</a><a id="L1792" href="#L1792">1792</a><a id="L1793" href="#L1793">1793</a><a id="L1794" href="#L1794">1794</a><a id="L1795" href="#L1795">1795</a><a id="L1796" href="#L1796">1796</a><a id="L1797" href="#L1797">1797</a><a id="L1798" href="#L1798">1798</a><a id="L1799" href="#L1799">1799</a><a id="L1800" href="#L1800">1800</a><a id="L1801" href="#L1801">1801</a><a id="L1802" href="#L1802">1802</a><a id="L1803" href="#L1803">1803</a><a id="L1804" href="#L1804">1804</a><a id="L1805" href="#L1805">1805</a><a id="L1806" href="#L1806">1806</a><a id="L1807" href="#L1807">1807</a><a id="L1808" href="#L1808">1808</a><a id="L1809" href="#L1809">1809</a><a id="L1810" href="#L1810">1810</a><a id="L1811" href="#L1811">1811</a><a id="L1812" href="#L1812">1812</a><a id="L1813" href="#L1813">1813</a><a id="L1814" href="#L1814">1814</a><a id="L1815" href="#L1815">1815</a><a id="L1816" href="#L1816">1816</a><a id="L1817" href="#L1817">1817</a><a id="L1818" href="#L1818">1818</a><a id="L1819" href="#L1819">1819</a><a id="L1820" href="#L1820">1820</a><a id="L1821" href="#L1821">1821</a><a id="L1822" href="#L1822">1822</a><a id="L1823" href="#L1823">1823</a><a id="L1824" href="#L1824">1824</a><a id="L1825" href="#L1825">1825</a><a id="L1826" href="#L1826">1826</a><a id="L1827" href="#L1827">1827</a><a id="L1828" href="#L1828">1828</a><a id="L1829" href="#L1829">1829</a><a id="L1830" href="#L1830">1830</a><a id="L1831" href="#L1831">1831</a><a id="L1832" href="#L1832">1832</a><a id="L1833" href="#L1833">1833</a><a id="L1834" href="#L1834">1834</a><a id="L1835" href="#L1835">1835</a><a id="L1836" href="#L1836">1836</a><a id="L1837" href="#L1837">1837</a><a id="L1838" href="#L1838">1838</a><a id="L1839" href="#L1839">1839</a><a id="L1840" href="#L1840">1840</a><a id="L1841" href="#L1841">1841</a><a id="L1842" href="#L1842">1842</a><a id="L1843" href="#L1843">1843</a><a id="L1844" href="#L1844">1844</a><a id="L1845" href="#L1845">1845</a><a id="L1846" href="#L1846">1846</a><a id="L1847" href="#L1847">1847</a><a id="L1848" href="#L1848">1848</a><a id="L1849" href="#L1849">1849</a><a id="L1850" href="#L1850">1850</a><a id="L1851" href="#L1851">1851</a><a id="L1852" href="#L1852">1852</a><a id="L1853" href="#L1853">1853</a><a id="L1854" href="#L1854">1854</a><a id="L1855" href="#L1855">1855</a><a id="L1856" href="#L1856">1856</a><a id="L1857" href="#L1857">1857</a><a id="L1858" href="#L1858">1858</a><a id="L1859" href="#L1859">1859</a><a id="L1860" href="#L1860">1860</a><a id="L1861" href="#L1861">1861</a><a id="L1862" href="#L1862">1862</a><a id="L1863" href="#L1863">1863</a><a id="L1864" href="#L1864">1864</a><a id="L1865" href="#L1865">1865</a><a id="L1866" href="#L1866">1866</a><a id="L1867" href="#L1867">1867</a><a id="L1868" href="#L1868">1868</a><a id="L1869" href="#L1869">1869</a><a id="L1870" href="#L1870">1870</a><a id="L1871" href="#L1871">1871</a><a id="L1872" href="#L1872">1872</a><a id="L1873" href="#L1873">1873</a><a id="L1874" href="#L1874">1874</a><a id="L1875" href="#L1875">1875</a><a id="L1876" href="#L1876">1876</a><a id="L1877" href="#L1877">1877</a><a id="L1878" href="#L1878">1878</a><a id="L1879" href="#L1879">1879</a><a id="L1880" href="#L1880">1880</a><a id="L1881" href="#L1881">1881</a><a id="L1882" href="#L1882">1882</a><a id="L1883" href="#L1883">1883</a><a id="L1884" href="#L1884">1884</a><a id="L1885" href="#L1885">1885</a><a id="L1886" href="#L1886">1886</a><a id="L1887" href="#L1887">1887</a><a id="L1888" href="#L1888">1888</a><a id="L1889" href="#L1889">1889</a><a id="L1890" href="#L1890">1890</a><a id="L1891" href="#L1891">1891</a><a id="L1892" href="#L1892">1892</a><a id="L1893" href="#L1893">1893</a><a id="L1894" href="#L1894">1894</a><a id="L1895" href="#L1895">1895</a><a id="L1896" href="#L1896">1896</a><a id="L1897" href="#L1897">1897</a><a id="L1898" href="#L1898">1898</a><a id="L1899" href="#L1899">1899</a><a id="L1900" href="#L1900">1900</a><a id="L1901" href="#L1901">1901</a><a id="L1902" href="#L1902">1902</a><a id="L1903" href="#L1903">1903</a><a id="L1904" href="#L1904">1904</a><a id="L1905" href="#L1905">1905</a><a id="L1906" href="#L1906">1906</a><a id="L1907" href="#L1907">1907</a><a id="L1908" href="#L1908">1908</a><a id="L1909" href="#L1909">1909</a><a id="L1910" href="#L1910">1910</a><a id="L1911" href="#L1911">1911</a><a id="L1912" href="#L1912">1912</a><a id="L1913" href="#L1913">1913</a><a id="L1914" href="#L1914">1914</a><a id="L1915" href="#L1915">1915</a><a id="L1916" href="#L1916">1916</a><a id="L1917" href="#L1917">1917</a><a id="L1918" href="#L1918">1918</a><a id="L1919" href="#L1919">1919</a><a id="L1920" href="#L1920">1920</a><a id="L1921" href="#L1921">1921</a><a id="L1922" href="#L1922">1922</a><a id="L1923" href="#L1923">1923</a><a id="L1924" href="#L1924">1924</a><a id="L1925" href="#L1925">1925</a><a id="L1926" href="#L1926">1926</a><a id="L1927" href="#L1927">1927</a><a id="L1928" href="#L1928">1928</a><a id="L1929" href="#L1929">1929</a><a id="L1930" href="#L1930">1930</a><a id="L1931" href="#L1931">1931</a><a id="L1932" href="#L1932">1932</a><a id="L1933" href="#L1933">1933</a><a id="L1934" href="#L1934">1934</a><a id="L1935" href="#L1935">1935</a><a id="L1936" href="#L1936">1936</a><a id="L1937" href="#L1937">1937</a><a id="L1938" href="#L1938">1938</a><a id="L1939" href="#L1939">1939</a><a id="L1940" href="#L1940">1940</a><a id="L1941" href="#L1941">1941</a><a id="L1942" href="#L1942">1942</a><a id="L1943" href="#L1943">1943</a><a id="L1944" href="#L1944">1944</a><a id="L1945" href="#L1945">1945</a><a id="L1946" href="#L1946">1946</a><a id="L1947" href="#L1947">1947</a><a id="L1948" href="#L1948">1948</a><a id="L1949" href="#L1949">1949</a><a id="L1950" href="#L1950">1950</a><a id="L1951" href="#L1951">1951</a><a id="L1952" href="#L1952">1952</a><a id="L1953" href="#L1953">1953</a><a id="L1954" href="#L1954">1954</a><a id="L1955" href="#L1955">1955</a><a id="L1956" href="#L1956">1956</a><a id="L1957" href="#L1957">1957</a><a id="L1958" href="#L1958">1958</a><a id="L1959" href="#L1959">1959</a><a id="L1960" href="#L1960">1960</a><a id="L1961" href="#L1961">1961</a><a id="L1962" href="#L1962">1962</a><a id="L1963" href="#L1963">1963</a><a id="L1964" href="#L1964">1964</a><a id="L1965" href="#L1965">1965</a><a id="L1966" href="#L1966">1966</a><a id="L1967" href="#L1967">1967</a><a id="L1968" href="#L1968">1968</a><a id="L1969" href="#L1969">1969</a><a id="L1970" href="#L1970">1970</a><a id="L1971" href="#L1971">1971</a><a id="L1972" href="#L1972">1972</a><a id="L1973" href="#L1973">1973</a><a id="L1974" href="#L1974">1974</a><a id="L1975" href="#L1975">1975</a><a id="L1976" href="#L1976">1976</a><a id="L1977" href="#L1977">1977</a><a id="L1978" href="#L1978">1978</a><a id="L1979" href="#L1979">1979</a><a id="L1980" href="#L1980">1980</a><a id="L1981" href="#L1981">1981</a><a id="L1982" href="#L1982">1982</a><a id="L1983" href="#L1983">1983</a><a id="L1984" href="#L1984">1984</a><a id="L1985" href="#L1985">1985</a><a id="L1986" href="#L1986">1986</a><a id="L1987" href="#L1987">1987</a><a id="L1988" href="#L1988">1988</a><a id="L1989" href="#L1989">1989</a><a id="L1990" href="#L1990">1990</a><a id="L1991" href="#L1991">1991</a><a id="L1992" href="#L1992">1992</a><a id="L1993" href="#L1993">1993</a><a id="L1994" href="#L1994">1994</a><a id="L1995" href="#L1995">1995</a><a id="L1996" href="#L1996">1996</a><a id="L1997" href="#L1997">1997</a><a id="L1998" href="#L1998">1998</a><a id="L1999" href="#L1999">1999</a><a id="L2000" href="#L2000">2000</a><a id="L2001" href="#L2001">2001</a><a id="L2002" href="#L2002">2002</a><a id="L2003" href="#L2003">2003</a><a id="L2004" href="#L2004">2004</a><a id="L2005" href="#L2005">2005</a><a id="L2006" href="#L2006">2006</a><a id="L2007" href="#L2007">2007</a><a id="L2008" href="#L2008">2008</a><a id="L2009" href="#L2009">2009</a><a id="L2010" href="#L2010">2010</a><a id="L2011" href="#L2011">2011</a><a id="L2012" href="#L2012">2012</a><a id="L2013" href="#L2013">2013</a><a id="L2014" href="#L2014">2014</a><a id="L2015" href="#L2015">2015</a><a id="L2016" href="#L2016">2016</a><a id="L2017" href="#L2017">2017</a><a id="L2018" href="#L2018">2018</a><a id="L2019" href="#L2019">2019</a><a id="L2020" href="#L2020">2020</a><a id="L2021" href="#L2021">2021</a><a id="L2022" href="#L2022">2022</a><a id="L2023" href="#L2023">2023</a><a id="L2024" href="#L2024">2024</a><a id="L2025" href="#L2025">2025</a><a id="L2026" href="#L2026">2026</a><a id="L2027" href="#L2027">2027</a><a id="L2028" href="#L2028">2028</a><a id="L2029" href="#L2029">2029</a><a id="L2030" href="#L2030">2030</a><a id="L2031" href="#L2031">2031</a><a id="L2032" href="#L2032">2032</a><a id="L2033" href="#L2033">2033</a><a id="L2034" href="#L2034">2034</a><a id="L2035" href="#L2035">2035</a><a id="L2036" href="#L2036">2036</a><a id="L2037" href="#L2037">2037</a><a id="L2038" href="#L2038">2038</a><a id="L2039" href="#L2039">2039</a><a id="L2040" href="#L2040">2040</a><a id="L2041" href="#L2041">2041</a><a id="L2042" href="#L2042">2042</a><a id="L2043" href="#L2043">2043</a><a id="L2044" href="#L2044">2044</a><a id="L2045" href="#L2045">2045</a><a id="L2046" href="#L2046">2046</a><a id="L2047" href="#L2047">2047</a><a id="L2048" href="#L2048">2048</a><a id="L2049" href="#L2049">2049</a><a id="L2050" href="#L2050">2050</a><a id="L2051" href="#L2051">2051</a><a id="L2052" href="#L2052">2052</a><a id="L2053" href="#L2053">2053</a><a id="L2054" href="#L2054">2054</a><a id="L2055" href="#L2055">2055</a><a id="L2056" href="#L2056">2056</a><a id="L2057" href="#L2057">2057</a><a id="L2058" href="#L2058">2058</a><a id="L2059" href="#L2059">2059</a><a id="L2060" href="#L2060">2060</a><a id="L2061" href="#L2061">2061</a><a id="L2062" href="#L2062">2062</a><a id="L2063" href="#L2063">2063</a><a id="L2064" href="#L2064">2064</a><a id="L2065" href="#L2065">2065</a><a id="L2066" href="#L2066">2066</a><a id="L2067" href="#L2067">2067</a><a id="L2068" href="#L2068">2068</a><a id="L2069" href="#L2069">2069</a><a id="L2070" href="#L2070">2070</a><a id="L2071" href="#L2071">2071</a><a id="L2072" href="#L2072">2072</a><a id="L2073" href="#L2073">2073</a><a id="L2074" href="#L2074">2074</a><a id="L2075" href="#L2075">2075</a><a id="L2076" href="#L2076">2076</a><a id="L2077" href="#L2077">2077</a><a id="L2078" href="#L2078">2078</a><a id="L2079" href="#L2079">2079</a><a id="L2080" href="#L2080">2080</a><a id="L2081" href="#L2081">2081</a><a id="L2082" href="#L2082">2082</a><a id="L2083" href="#L2083">2083</a><a id="L2084" href="#L2084">2084</a><a id="L2085" href="#L2085">2085</a><a id="L2086" href="#L2086">2086</a><a id="L2087" href="#L2087">2087</a><a id="L2088" href="#L2088">2088</a><a id="L2089" href="#L2089">2089</a><a id="L2090" href="#L2090">2090</a><a id="L2091" href="#L2091">2091</a><a id="L2092" href="#L2092">2092</a><a id="L2093" href="#L2093">2093</a><a id="L2094" href="#L2094">2094</a><a id="L2095" href="#L2095">2095</a><a id="L2096" href="#L2096">2096</a><a id="L2097" href="#L2097">2097</a><a id="L2098" href="#L2098">2098</a><a id="L2099" href="#L2099">2099</a><a id="L2100" href="#L2100">2100</a><a id="L2101" href="#L2101">2101</a><a id="L2102" href="#L2102">2102</a><a id="L2103" href="#L2103">2103</a><a id="L2104" href="#L2104">2104</a><a id="L2105" href="#L2105">2105</a><a id="L2106" href="#L2106">2106</a><a id="L2107" href="#L2107">2107</a><a id="L2108" href="#L2108">2108</a><a id="L2109" href="#L2109">2109</a><a id="L2110" href="#L2110">2110</a><a id="L2111" href="#L2111">2111</a><a id="L2112" href="#L2112">2112</a><a id="L2113" href="#L2113">2113</a><a id="L2114" href="#L2114">2114</a><a id="L2115" href="#L2115">2115</a><a id="L2116" href="#L2116">2116</a><a id="L2117" href="#L2117">2117</a><a id="L2118" href="#L2118">2118</a><a id="L2119" href="#L2119">2119</a><a id="L2120" href="#L2120">2120</a><a id="L2121" href="#L2121">2121</a><a id="L2122" href="#L2122">2122</a><a id="L2123" href="#L2123">2123</a><a id="L2124" href="#L2124">2124</a><a id="L2125" href="#L2125">2125</a><a id="L2126" href="#L2126">2126</a><a id="L2127" href="#L2127">2127</a><a id="L2128" href="#L2128">2128</a><a id="L2129" href="#L2129">2129</a><a id="L2130" href="#L2130">2130</a><a id="L2131" href="#L2131">2131</a><a id="L2132" href="#L2132">2132</a><a id="L2133" href="#L2133">2133</a><a id="L2134" href="#L2134">2134</a><a id="L2135" href="#L2135">2135</a><a id="L2136" href="#L2136">2136</a><a id="L2137" href="#L2137">2137</a><a id="L2138" href="#L2138">2138</a><a id="L2139" href="#L2139">2139</a><a id="L2140" href="#L2140">2140</a><a id="L2141" href="#L2141">2141</a><a id="L2142" href="#L2142">2142</a><a id="L2143" href="#L2143">2143</a><a id="L2144" href="#L2144">2144</a><a id="L2145" href="#L2145">2145</a><a id="L2146" href="#L2146">2146</a><a id="L2147" href="#L2147">2147</a><a id="L2148" href="#L2148">2148</a><a id="L2149" href="#L2149">2149</a><a id="L2150" href="#L2150">2150</a><a id="L2151" href="#L2151">2151</a><a id="L2152" href="#L2152">2152</a><a id="L2153" href="#L2153">2153</a><a id="L2154" href="#L2154">2154</a><a id="L2155" href="#L2155">2155</a><a id="L2156" href="#L2156">2156</a><a id="L2157" href="#L2157">2157</a><a id="L2158" href="#L2158">2158</a><a id="L2159" href="#L2159">2159</a><a id="L2160" href="#L2160">2160</a><a id="L2161" href="#L2161">2161</a><a id="L2162" href="#L2162">2162</a><a id="L2163" href="#L2163">2163</a><a id="L2164" href="#L2164">2164</a><a id="L2165" href="#L2165">2165</a><a id="L2166" href="#L2166">2166</a><a id="L2167" href="#L2167">2167</a><a id="L2168" href="#L2168">2168</a><a id="L2169" href="#L2169">2169</a><a id="L2170" href="#L2170">2170</a><a id="L2171" href="#L2171">2171</a><a id="L2172" href="#L2172">2172</a><a id="L2173" href="#L2173">2173</a><a id="L2174" href="#L2174">2174</a><a id="L2175" href="#L2175">2175</a><a id="L2176" href="#L2176">2176</a><a id="L2177" href="#L2177">2177</a><a id="L2178" href="#L2178">2178</a><a id="L2179" href="#L2179">2179</a><a id="L2180" href="#L2180">2180</a><a id="L2181" href="#L2181">2181</a><a id="L2182" href="#L2182">2182</a><a id="L2183" href="#L2183">2183</a><a id="L2184" href="#L2184">2184</a><a id="L2185" href="#L2185">2185</a><a id="L2186" href="#L2186">2186</a><a id="L2187" href="#L2187">2187</a><a id="L2188" href="#L2188">2188</a><a id="L2189" href="#L2189">2189</a><a id="L2190" href="#L2190">2190</a><a id="L2191" href="#L2191">2191</a><a id="L2192" href="#L2192">2192</a><a id="L2193" href="#L2193">2193</a><a id="L2194" href="#L2194">2194</a><a id="L2195" href="#L2195">2195</a><a id="L2196" href="#L2196">2196</a><a id="L2197" href="#L2197">2197</a><a id="L2198" href="#L2198">2198</a><a id="L2199" href="#L2199">2199</a><a id="L2200" href="#L2200">2200</a><a id="L2201" href="#L2201">2201</a><a id="L2202" href="#L2202">2202</a><a id="L2203" href="#L2203">2203</a><a id="L2204" href="#L2204">2204</a><a id="L2205" href="#L2205">2205</a><a id="L2206" href="#L2206">2206</a><a id="L2207" href="#L2207">2207</a><a id="L2208" href="#L2208">2208</a><a id="L2209" href="#L2209">2209</a><a id="L2210" href="#L2210">2210</a><a id="L2211" href="#L2211">2211</a><a id="L2212" href="#L2212">2212</a><a id="L2213" href="#L2213">2213</a><a id="L2214" href="#L2214">2214</a><a id="L2215" href="#L2215">2215</a><a id="L2216" href="#L2216">2216</a><a id="L2217" href="#L2217">2217</a><a id="L2218" href="#L2218">2218</a><a id="L2219" href="#L2219">2219</a><a id="L2220" href="#L2220">2220</a><a id="L2221" href="#L2221">2221</a><a id="L2222" href="#L2222">2222</a><a id="L2223" href="#L2223">2223</a><a id="L2224" href="#L2224">2224</a><a id="L2225" href="#L2225">2225</a><a id="L2226" href="#L2226">2226</a><a id="L2227" href="#L2227">2227</a><a id="L2228" href="#L2228">2228</a><a id="L2229" href="#L2229">2229</a><a id="L2230" href="#L2230">2230</a><a id="L2231" href="#L2231">2231</a><a id="L2232" href="#L2232">2232</a><a id="L2233" href="#L2233">2233</a><a id="L2234" href="#L2234">2234</a><a id="L2235" href="#L2235">2235</a><a id="L2236" href="#L2236">2236</a><a id="L2237" href="#L2237">2237</a><a id="L2238" href="#L2238">2238</a><a id="L2239" href="#L2239">2239</a><a id="L2240" href="#L2240">2240</a><a id="L2241" href="#L2241">2241</a><a id="L2242" href="#L2242">2242</a><a id="L2243" href="#L2243">2243</a><a id="L2244" href="#L2244">2244</a><a id="L2245" href="#L2245">2245</a><a id="L2246" href="#L2246">2246</a><a id="L2247" href="#L2247">2247</a><a id="L2248" href="#L2248">2248</a><a id="L2249" href="#L2249">2249</a><a id="L2250" href="#L2250">2250</a><a id="L2251" href="#L2251">2251</a><a id="L2252" href="#L2252">2252</a><a id="L2253" href="#L2253">2253</a><a id="L2254" href="#L2254">2254</a><a id="L2255" href="#L2255">2255</a><a id="L2256" href="#L2256">2256</a><a id="L2257" href="#L2257">2257</a><a id="L2258" href="#L2258">2258</a><a id="L2259" href="#L2259">2259</a><a id="L2260" href="#L2260">2260</a><a id="L2261" href="#L2261">2261</a><a id="L2262" href="#L2262">2262</a><a id="L2263" href="#L2263">2263</a><a id="L2264" href="#L2264">2264</a><a id="L2265" href="#L2265">2265</a><a id="L2266" href="#L2266">2266</a><a id="L2267" href="#L2267">2267</a><a id="L2268" href="#L2268">2268</a><a id="L2269" href="#L2269">2269</a><a id="L2270" href="#L2270">2270</a><a id="L2271" href="#L2271">2271</a><a id="L2272" href="#L2272">2272</a><a id="L2273" href="#L2273">2273</a><a id="L2274" href="#L2274">2274</a><a id="L2275" href="#L2275">2275</a><a id="L2276" href="#L2276">2276</a><a id="L2277" href="#L2277">2277</a><a id="L2278" href="#L2278">2278</a><a id="L2279" href="#L2279">2279</a><a id="L2280" href="#L2280">2280</a><a id="L2281" href="#L2281">2281</a><a id="L2282" href="#L2282">2282</a><a id="L2283" href="#L2283">2283</a><a id="L2284" href="#L2284">2284</a><a id="L2285" href="#L2285">2285</a><a id="L2286" href="#L2286">2286</a><a id="L2287" href="#L2287">2287</a><a id="L2288" href="#L2288">2288</a><a id="L2289" href="#L2289">2289</a><a id="L2290" href="#L2290">2290</a><a id="L2291" href="#L2291">2291</a><a id="L2292" href="#L2292">2292</a><a id="L2293" href="#L2293">2293</a><a id="L2294" href="#L2294">2294</a><a id="L2295" href="#L2295">2295</a><a id="L2296" href="#L2296">2296</a><a id="L2297" href="#L2297">2297</a><a id="L2298" href="#L2298">2298</a><a id="L2299" href="#L2299">2299</a><a id="L2300" href="#L2300">2300</a><a id="L2301" href="#L2301">2301</a><a id="L2302" href="#L2302">2302</a><a id="L2303" href="#L2303">2303</a><a id="L2304" href="#L2304">2304</a><a id="L2305" href="#L2305">2305</a><a id="L2306" href="#L2306">2306</a><a id="L2307" href="#L2307">2307</a><a id="L2308" href="#L2308">2308</a><a id="L2309" href="#L2309">2309</a><a id="L2310" href="#L2310">2310</a><a id="L2311" href="#L2311">2311</a><a id="L2312" href="#L2312">2312</a><a id="L2313" href="#L2313">2313</a><a id="L2314" href="#L2314">2314</a><a id="L2315" href="#L2315">2315</a><a id="L2316" href="#L2316">2316</a><a id="L2317" href="#L2317">2317</a><a id="L2318" href="#L2318">2318</a><a id="L2319" href="#L2319">2319</a><a id="L2320" href="#L2320">2320</a><a id="L2321" href="#L2321">2321</a><a id="L2322" href="#L2322">2322</a><a id="L2323" href="#L2323">2323</a><a id="L2324" href="#L2324">2324</a><a id="L2325" href="#L2325">2325</a><a id="L2326" href="#L2326">2326</a><a id="L2327" href="#L2327">2327</a><a id="L2328" href="#L2328">2328</a><a id="L2329" href="#L2329">2329</a><a id="L2330" href="#L2330">2330</a><a id="L2331" href="#L2331">2331</a><a id="L2332" href="#L2332">2332</a><a id="L2333" href="#L2333">2333</a><a id="L2334" href="#L2334">2334</a><a id="L2335" href="#L2335">2335</a><a id="L2336" href="#L2336">2336</a><a id="L2337" href="#L2337">2337</a><a id="L2338" href="#L2338">2338</a><a id="L2339" href="#L2339">2339</a><a id="L2340" href="#L2340">2340</a><a id="L2341" href="#L2341">2341</a><a id="L2342" href="#L2342">2342</a><a id="L2343" href="#L2343">2343</a><a id="L2344" href="#L2344">2344</a><a id="L2345" href="#L2345">2345</a><a id="L2346" href="#L2346">2346</a><a id="L2347" href="#L2347">2347</a><a id="L2348" href="#L2348">2348</a><a id="L2349" href="#L2349">2349</a><a id="L2350" href="#L2350">2350</a><a id="L2351" href="#L2351">2351</a><a id="L2352" href="#L2352">2352</a><a id="L2353" href="#L2353">2353</a><a id="L2354" href="#L2354">2354</a><a id="L2355" href="#L2355">2355</a><a id="L2356" href="#L2356">2356</a><a id="L2357" href="#L2357">2357</a><a id="L2358" href="#L2358">2358</a><a id="L2359" href="#L2359">2359</a><a id="L2360" href="#L2360">2360</a><a id="L2361" href="#L2361">2361</a><a id="L2362" href="#L2362">2362</a><a id="L2363" href="#L2363">2363</a><a id="L2364" href="#L2364">2364</a><a id="L2365" href="#L2365">2365</a><a id="L2366" href="#L2366">2366</a><a id="L2367" href="#L2367">2367</a><a id="L2368" href="#L2368">2368</a><a id="L2369" href="#L2369">2369</a><a id="L2370" href="#L2370">2370</a><a id="L2371" href="#L2371">2371</a><a id="L2372" href="#L2372">2372</a><a id="L2373" href="#L2373">2373</a><a id="L2374" href="#L2374">2374</a><a id="L2375" href="#L2375">2375</a><a id="L2376" href="#L2376">2376</a><a id="L2377" href="#L2377">2377</a><a id="L2378" href="#L2378">2378</a><a id="L2379" href="#L2379">2379</a><a id="L2380" href="#L2380">2380</a><a id="L2381" href="#L2381">2381</a><a id="L2382" href="#L2382">2382</a><a id="L2383" href="#L2383">2383</a><a id="L2384" href="#L2384">2384</a><a id="L2385" href="#L2385">2385</a><a id="L2386" href="#L2386">2386</a><a id="L2387" href="#L2387">2387</a><a id="L2388" href="#L2388">2388</a><a id="L2389" href="#L2389">2389</a><a id="L2390" href="#L2390">2390</a><a id="L2391" href="#L2391">2391</a><a id="L2392" href="#L2392">2392</a><a id="L2393" href="#L2393">2393</a><a id="L2394" href="#L2394">2394</a><a id="L2395" href="#L2395">2395</a><a id="L2396" href="#L2396">2396</a><a id="L2397" href="#L2397">2397</a><a id="L2398" href="#L2398">2398</a><a id="L2399" href="#L2399">2399</a><a id="L2400" href="#L2400">2400</a><a id="L2401" href="#L2401">2401</a><a id="L2402" href="#L2402">2402</a><a id="L2403" href="#L2403">2403</a><a id="L2404" href="#L2404">2404</a><a id="L2405" href="#L2405">2405</a><a id="L2406" href="#L2406">2406</a><a id="L2407" href="#L2407">2407</a><a id="L2408" href="#L2408">2408</a><a id="L2409" href="#L2409">2409</a><a id="L2410" href="#L2410">2410</a><a id="L2411" href="#L2411">2411</a><a id="L2412" href="#L2412">2412</a><a id="L2413" href="#L2413">2413</a><a id="L2414" href="#L2414">2414</a><a id="L2415" href="#L2415">2415</a><a id="L2416" href="#L2416">2416</a><a id="L2417" href="#L2417">2417</a><a id="L2418" href="#L2418">2418</a><a id="L2419" href="#L2419">2419</a><a id="L2420" href="#L2420">2420</a><a id="L2421" href="#L2421">2421</a><a id="L2422" href="#L2422">2422</a><a id="L2423" href="#L2423">2423</a><a id="L2424" href="#L2424">2424</a><a id="L2425" href="#L2425">2425</a><a id="L2426" href="#L2426">2426</a><a id="L2427" href="#L2427">2427</a><a id="L2428" href="#L2428">2428</a><a id="L2429" href="#L2429">2429</a><a id="L2430" href="#L2430">2430</a><a id="L2431" href="#L2431">2431</a><a id="L2432" href="#L2432">2432</a><a id="L2433" href="#L2433">2433</a><a id="L2434" href="#L2434">2434</a><a id="L2435" href="#L2435">2435</a><a id="L2436" href="#L2436">2436</a><a id="L2437" href="#L2437">2437</a><a id="L2438" href="#L2438">2438</a><a id="L2439" href="#L2439">2439</a><a id="L2440" href="#L2440">2440</a><a id="L2441" href="#L2441">2441</a><a id="L2442" href="#L2442">2442</a><a id="L2443" href="#L2443">2443</a><a id="L2444" href="#L2444">2444</a><a id="L2445" href="#L2445">2445</a><a id="L2446" href="#L2446">2446</a><a id="L2447" href="#L2447">2447</a><a id="L2448" href="#L2448">2448</a><a id="L2449" href="#L2449">2449</a><a id="L2450" href="#L2450">2450</a><a id="L2451" href="#L2451">2451</a><a id="L2452" href="#L2452">2452</a><a id="L2453" href="#L2453">2453</a><a id="L2454" href="#L2454">2454</a><a id="L2455" href="#L2455">2455</a><a id="L2456" href="#L2456">2456</a><a id="L2457" href="#L2457">2457</a><a id="L2458" href="#L2458">2458</a><a id="L2459" href="#L2459">2459</a><a id="L2460" href="#L2460">2460</a><a id="L2461" href="#L2461">2461</a><a id="L2462" href="#L2462">2462</a><a id="L2463" href="#L2463">2463</a><a id="L2464" href="#L2464">2464</a><a id="L2465" href="#L2465">2465</a><a id="L2466" href="#L2466">2466</a><a id="L2467" href="#L2467">2467</a><a id="L2468" href="#L2468">2468</a><a id="L2469" href="#L2469">2469</a><a id="L2470" href="#L2470">2470</a><a id="L2471" href="#L2471">2471</a><a id="L2472" href="#L2472">2472</a><a id="L2473" href="#L2473">2473</a><a id="L2474" href="#L2474">2474</a><a id="L2475" href="#L2475">2475</a><a id="L2476" href="#L2476">2476</a><a id="L2477" href="#L2477">2477</a><a id="L2478" href="#L2478">2478</a><a id="L2479" href="#L2479">2479</a><a id="L2480" href="#L2480">2480</a><a id="L2481" href="#L2481">2481</a><a id="L2482" href="#L2482">2482</a><a id="L2483" href="#L2483">2483</a><a id="L2484" href="#L2484">2484</a><a id="L2485" href="#L2485">2485</a><a id="L2486" href="#L2486">2486</a><a id="L2487" href="#L2487">2487</a><a id="L2488" href="#L2488">2488</a><a id="L2489" href="#L2489">2489</a><a id="L2490" href="#L2490">2490</a><a id="L2491" href="#L2491">2491</a><a id="L2492" href="#L2492">2492</a><a id="L2493" href="#L2493">2493</a><a id="L2494" href="#L2494">2494</a><a id="L2495" href="#L2495">2495</a><a id="L2496" href="#L2496">2496</a><a id="L2497" href="#L2497">2497</a><a id="L2498" href="#L2498">2498</a><a id="L2499" href="#L2499">2499</a><a id="L2500" href="#L2500">2500</a><a id="L2501" href="#L2501">2501</a><a id="L2502" href="#L2502">2502</a><a id="L2503" href="#L2503">2503</a><a id="L2504" href="#L2504">2504</a><a id="L2505" href="#L2505">2505</a><a id="L2506" href="#L2506">2506</a><a id="L2507" href="#L2507">2507</a><a id="L2508" href="#L2508">2508</a><a id="L2509" href="#L2509">2509</a><a id="L2510" href="#L2510">2510</a><a id="L2511" href="#L2511">2511</a><a id="L2512" href="#L2512">2512</a><a id="L2513" href="#L2513">2513</a><a id="L2514" href="#L2514">2514</a><a id="L2515" href="#L2515">2515</a><a id="L2516" href="#L2516">2516</a><a id="L2517" href="#L2517">2517</a><a id="L2518" href="#L2518">2518</a><a id="L2519" href="#L2519">2519</a><a id="L2520" href="#L2520">2520</a><a id="L2521" href="#L2521">2521</a><a id="L2522" href="#L2522">2522</a><a id="L2523" href="#L2523">2523</a><a id="L2524" href="#L2524">2524</a><a id="L2525" href="#L2525">2525</a><a id="L2526" href="#L2526">2526</a><a id="L2527" href="#L2527">2527</a><a id="L2528" href="#L2528">2528</a><a id="L2529" href="#L2529">2529</a><a id="L2530" href="#L2530">2530</a><a id="L2531" href="#L2531">2531</a><a id="L2532" href="#L2532">2532</a><a id="L2533" href="#L2533">2533</a><a id="L2534" href="#L2534">2534</a><a id="L2535" href="#L2535">2535</a><a id="L2536" href="#L2536">2536</a><a id="L2537" href="#L2537">2537</a><a id="L2538" href="#L2538">2538</a><a id="L2539" href="#L2539">2539</a><a id="L2540" href="#L2540">2540</a><a id="L2541" href="#L2541">2541</a><a id="L2542" href="#L2542">2542</a><a id="L2543" href="#L2543">2543</a><a id="L2544" href="#L2544">2544</a><a id="L2545" href="#L2545">2545</a><a id="L2546" href="#L2546">2546</a><a id="L2547" href="#L2547">2547</a><a id="L2548" href="#L2548">2548</a><a id="L2549" href="#L2549">2549</a><a id="L2550" href="#L2550">2550</a><a id="L2551" href="#L2551">2551</a><a id="L2552" href="#L2552">2552</a><a id="L2553" href="#L2553">2553</a><a id="L2554" href="#L2554">2554</a><a id="L2555" href="#L2555">2555</a><a id="L2556" href="#L2556">2556</a><a id="L2557" href="#L2557">2557</a><a id="L2558" href="#L2558">2558</a><a id="L2559" href="#L2559">2559</a><a id="L2560" href="#L2560">2560</a><a id="L2561" href="#L2561">2561</a><a id="L2562" href="#L2562">2562</a><a id="L2563" href="#L2563">2563</a><a id="L2564" href="#L2564">2564</a><a id="L2565" href="#L2565">2565</a><a id="L2566" href="#L2566">2566</a><a id="L2567" href="#L2567">2567</a><a id="L2568" href="#L2568">2568</a><a id="L2569" href="#L2569">2569</a><a id="L2570" href="#L2570">2570</a><a id="L2571" href="#L2571">2571</a><a id="L2572" href="#L2572">2572</a><a id="L2573" href="#L2573">2573</a><a id="L2574" href="#L2574">2574</a><a id="L2575" href="#L2575">2575</a><a id="L2576" href="#L2576">2576</a><a id="L2577" href="#L2577">2577</a><a id="L2578" href="#L2578">2578</a><a id="L2579" href="#L2579">2579</a><a id="L2580" href="#L2580">2580</a><a id="L2581" href="#L2581">2581</a><a id="L2582" href="#L2582">2582</a><a id="L2583" href="#L2583">2583</a><a id="L2584" href="#L2584">2584</a><a id="L2585" href="#L2585">2585</a><a id="L2586" href="#L2586">2586</a><a id="L2587" href="#L2587">2587</a><a id="L2588" href="#L2588">2588</a><a id="L2589" href="#L2589">2589</a><a id="L2590" href="#L2590">2590</a><a id="L2591" href="#L2591">2591</a><a id="L2592" href="#L2592">2592</a><a id="L2593" href="#L2593">2593</a><a id="L2594" href="#L2594">2594</a><a id="L2595" href="#L2595">2595</a><a id="L2596" href="#L2596">2596</a><a id="L2597" href="#L2597">2597</a><a id="L2598" href="#L2598">2598</a><a id="L2599" href="#L2599">2599</a><a id="L2600" href="#L2600">2600</a><a id="L2601" href="#L2601">2601</a><a id="L2602" href="#L2602">2602</a><a id="L2603" href="#L2603">2603</a><a id="L2604" href="#L2604">2604</a><a id="L2605" href="#L2605">2605</a><a id="L2606" href="#L2606">2606</a><a id="L2607" href="#L2607">2607</a><a id="L2608" href="#L2608">2608</a><a id="L2609" href="#L2609">2609</a><a id="L2610" href="#L2610">2610</a><a id="L2611" href="#L2611">2611</a><a id="L2612" href="#L2612">2612</a><a id="L2613" href="#L2613">2613</a><a id="L2614" href="#L2614">2614</a><a id="L2615" href="#L2615">2615</a><a id="L2616" href="#L2616">2616</a><a id="L2617" href="#L2617">2617</a><a id="L2618" href="#L2618">2618</a><a id="L2619" href="#L2619">2619</a><a id="L2620" href="#L2620">2620</a><a id="L2621" href="#L2621">2621</a><a id="L2622" href="#L2622">2622</a><a id="L2623" href="#L2623">2623</a><a id="L2624" href="#L2624">2624</a><a id="L2625" href="#L2625">2625</a><a id="L2626" href="#L2626">2626</a><a id="L2627" href="#L2627">2627</a><a id="L2628" href="#L2628">2628</a><a id="L2629" href="#L2629">2629</a><a id="L2630" href="#L2630">2630</a><a id="L2631" href="#L2631">2631</a><a id="L2632" href="#L2632">2632</a><a id="L2633" href="#L2633">2633</a><a id="L2634" href="#L2634">2634</a><a id="L2635" href="#L2635">2635</a><a id="L2636" href="#L2636">2636</a><a id="L2637" href="#L2637">2637</a><a id="L2638" href="#L2638">2638</a><a id="L2639" href="#L2639">2639</a><a id="L2640" href="#L2640">2640</a><a id="L2641" href="#L2641">2641</a><a id="L2642" href="#L2642">2642</a><a id="L2643" href="#L2643">2643</a><a id="L2644" href="#L2644">2644</a><a id="L2645" href="#L2645">2645</a><a id="L2646" href="#L2646">2646</a><a id="L2647" href="#L2647">2647</a><a id="L2648" href="#L2648">2648</a><a id="L2649" href="#L2649">2649</a><a id="L2650" href="#L2650">2650</a><a id="L2651" href="#L2651">2651</a><a id="L2652" href="#L2652">2652</a><a id="L2653" href="#L2653">2653</a><a id="L2654" href="#L2654">2654</a><a id="L2655" href="#L2655">2655</a><a id="L2656" href="#L2656">2656</a><a id="L2657" href="#L2657">2657</a><a id="L2658" href="#L2658">2658</a><a id="L2659" href="#L2659">2659</a><a id="L2660" href="#L2660">2660</a><a id="L2661" href="#L2661">2661</a><a id="L2662" href="#L2662">2662</a><a id="L2663" href="#L2663">2663</a><a id="L2664" href="#L2664">2664</a><a id="L2665" href="#L2665">2665</a><a id="L2666" href="#L2666">2666</a><a id="L2667" href="#L2667">2667</a><a id="L2668" href="#L2668">2668</a><a id="L2669" href="#L2669">2669</a><a id="L2670" href="#L2670">2670</a><a id="L2671" href="#L2671">2671</a><a id="L2672" href="#L2672">2672</a><a id="L2673" href="#L2673">2673</a><a id="L2674" href="#L2674">2674</a><a id="L2675" href="#L2675">2675</a><a id="L2676" href="#L2676">2676</a><a id="L2677" href="#L2677">2677</a><a id="L2678" href="#L2678">2678</a><a id="L2679" href="#L2679">2679</a><a id="L2680" href="#L2680">2680</a><a id="L2681" href="#L2681">2681</a><a id="L2682" href="#L2682">2682</a><a id="L2683" href="#L2683">2683</a><a id="L2684" href="#L2684">2684</a><a id="L2685" href="#L2685">2685</a><a id="L2686" href="#L2686">2686</a><a id="L2687" href="#L2687">2687</a><a id="L2688" href="#L2688">2688</a><a id="L2689" href="#L2689">2689</a><a id="L2690" href="#L2690">2690</a><a id="L2691" href="#L2691">2691</a><a id="L2692" href="#L2692">2692</a><a id="L2693" href="#L2693">2693</a><a id="L2694" href="#L2694">2694</a><a id="L2695" href="#L2695">2695</a><a id="L2696" href="#L2696">2696</a><a id="L2697" href="#L2697">2697</a><a id="L2698" href="#L2698">2698</a><a id="L2699" href="#L2699">2699</a><a id="L2700" href="#L2700">2700</a><a id="L2701" href="#L2701">2701</a><a id="L2702" href="#L2702">2702</a><a id="L2703" href="#L2703">2703</a><a id="L2704" href="#L2704">2704</a><a id="L2705" href="#L2705">2705</a><a id="L2706" href="#L2706">2706</a><a id="L2707" href="#L2707">2707</a><a id="L2708" href="#L2708">2708</a><a id="L2709" href="#L2709">2709</a><a id="L2710" href="#L2710">2710</a><a id="L2711" href="#L2711">2711</a><a id="L2712" href="#L2712">2712</a><a id="L2713" href="#L2713">2713</a><a id="L2714" href="#L2714">2714</a><a id="L2715" href="#L2715">2715</a><a id="L2716" href="#L2716">2716</a><a id="L2717" href="#L2717">2717</a><a id="L2718" href="#L2718">2718</a><a id="L2719" href="#L2719">2719</a><a id="L2720" href="#L2720">2720</a><a id="L2721" href="#L2721">2721</a><a id="L2722" href="#L2722">2722</a><a id="L2723" href="#L2723">2723</a><a id="L2724" href="#L2724">2724</a><a id="L2725" href="#L2725">2725</a><a id="L2726" href="#L2726">2726</a><a id="L2727" href="#L2727">2727</a><a id="L2728" href="#L2728">2728</a><a id="L2729" href="#L2729">2729</a><a id="L2730" href="#L2730">2730</a><a id="L2731" href="#L2731">2731</a><a id="L2732" href="#L2732">2732</a><a id="L2733" href="#L2733">2733</a><a id="L2734" href="#L2734">2734</a><a id="L2735" href="#L2735">2735</a><a id="L2736" href="#L2736">2736</a><a id="L2737" href="#L2737">2737</a><a id="L2738" href="#L2738">2738</a><a id="L2739" href="#L2739">2739</a><a id="L2740" href="#L2740">2740</a><a id="L2741" href="#L2741">2741</a><a id="L2742" href="#L2742">2742</a><a id="L2743" href="#L2743">2743</a><a id="L2744" href="#L2744">2744</a><a id="L2745" href="#L2745">2745</a><a id="L2746" href="#L2746">2746</a><a id="L2747" href="#L2747">2747</a><a id="L2748" href="#L2748">2748</a><a id="L2749" href="#L2749">2749</a><a id="L2750" href="#L2750">2750</a><a id="L2751" href="#L2751">2751</a><a id="L2752" href="#L2752">2752</a><a id="L2753" href="#L2753">2753</a><a id="L2754" href="#L2754">2754</a><a id="L2755" href="#L2755">2755</a><a id="L2756" href="#L2756">2756</a><a id="L2757" href="#L2757">2757</a><a id="L2758" href="#L2758">2758</a><a id="L2759" href="#L2759">2759</a><a id="L2760" href="#L2760">2760</a><a id="L2761" href="#L2761">2761</a><a id="L2762" href="#L2762">2762</a><a id="L2763" href="#L2763">2763</a><a id="L2764" href="#L2764">2764</a><a id="L2765" href="#L2765">2765</a><a id="L2766" href="#L2766">2766</a><a id="L2767" href="#L2767">2767</a><a id="L2768" href="#L2768">2768</a><a id="L2769" href="#L2769">2769</a><a id="L2770" href="#L2770">2770</a><a id="L2771" href="#L2771">2771</a><a id="L2772" href="#L2772">2772</a><a id="L2773" href="#L2773">2773</a><a id="L2774" href="#L2774">2774</a><a id="L2775" href="#L2775">2775</a><a id="L2776" href="#L2776">2776</a><a id="L2777" href="#L2777">2777</a><a id="L2778" href="#L2778">2778</a><a id="L2779" href="#L2779">2779</a><a id="L2780" href="#L2780">2780</a><a id="L2781" href="#L2781">2781</a><a id="L2782" href="#L2782">2782</a><a id="L2783" href="#L2783">2783</a><a id="L2784" href="#L2784">2784</a><a id="L2785" href="#L2785">2785</a><a id="L2786" href="#L2786">2786</a><a id="L2787" href="#L2787">2787</a><a id="L2788" href="#L2788">2788</a><a id="L2789" href="#L2789">2789</a><a id="L2790" href="#L2790">2790</a><a id="L2791" href="#L2791">2791</a><a id="L2792" href="#L2792">2792</a><a id="L2793" href="#L2793">2793</a><a id="L2794" href="#L2794">2794</a><a id="L2795" href="#L2795">2795</a><a id="L2796" href="#L2796">2796</a><a id="L2797" href="#L2797">2797</a><a id="L2798" href="#L2798">2798</a><a id="L2799" href="#L2799">2799</a><a id="L2800" href="#L2800">2800</a><a id="L2801" href="#L2801">2801</a><a id="L2802" href="#L2802">2802</a><a id="L2803" href="#L2803">2803</a><a id="L2804" href="#L2804">2804</a><a id="L2805" href="#L2805">2805</a><a id="L2806" href="#L2806">2806</a><a id="L2807" href="#L2807">2807</a><a id="L2808" href="#L2808">2808</a><a id="L2809" href="#L2809">2809</a><a id="L2810" href="#L2810">2810</a><a id="L2811" href="#L2811">2811</a><a id="L2812" href="#L2812">2812</a><a id="L2813" href="#L2813">2813</a><a id="L2814" href="#L2814">2814</a><a id="L2815" href="#L2815">2815</a><a id="L2816" href="#L2816">2816</a><a id="L2817" href="#L2817">2817</a><a id="L2818" href="#L2818">2818</a><a id="L2819" href="#L2819">2819</a><a id="L2820" href="#L2820">2820</a><a id="L2821" href="#L2821">2821</a><a id="L2822" href="#L2822">2822</a><a id="L2823" href="#L2823">2823</a><a id="L2824" href="#L2824">2824</a><a id="L2825" href="#L2825">2825</a><a id="L2826" href="#L2826">2826</a><a id="L2827" href="#L2827">2827</a><a id="L2828" href="#L2828">2828</a><a id="L2829" href="#L2829">2829</a><a id="L2830" href="#L2830">2830</a><a id="L2831" href="#L2831">2831</a><a id="L2832" href="#L2832">2832</a><a id="L2833" href="#L2833">2833</a><a id="L2834" href="#L2834">2834</a><a id="L2835" href="#L2835">2835</a><a id="L2836" href="#L2836">2836</a><a id="L2837" href="#L2837">2837</a><a id="L2838" href="#L2838">2838</a><a id="L2839" href="#L2839">2839</a><a id="L2840" href="#L2840">2840</a><a id="L2841" href="#L2841">2841</a><a id="L2842" href="#L2842">2842</a><a id="L2843" href="#L2843">2843</a><a id="L2844" href="#L2844">2844</a><a id="L2845" href="#L2845">2845</a><a id="L2846" href="#L2846">2846</a><a id="L2847" href="#L2847">2847</a><a id="L2848" href="#L2848">2848</a><a id="L2849" href="#L2849">2849</a><a id="L2850" href="#L2850">2850</a><a id="L2851" href="#L2851">2851</a><a id="L2852" href="#L2852">2852</a><a id="L2853" href="#L2853">2853</a><a id="L2854" href="#L2854">2854</a><a id="L2855" href="#L2855">2855</a><a id="L2856" href="#L2856">2856</a><a id="L2857" href="#L2857">2857</a><a id="L2858" href="#L2858">2858</a><a id="L2859" href="#L2859">2859</a><a id="L2860" href="#L2860">2860</a><a id="L2861" href="#L2861">2861</a><a id="L2862" href="#L2862">2862</a><a id="L2863" href="#L2863">2863</a><a id="L2864" href="#L2864">2864</a><a id="L2865" href="#L2865">2865</a><a id="L2866" href="#L2866">2866</a><a id="L2867" href="#L2867">2867</a><a id="L2868" href="#L2868">2868</a><a id="L2869" href="#L2869">2869</a><a id="L2870" href="#L2870">2870</a><a id="L2871" href="#L2871">2871</a><a id="L2872" href="#L2872">2872</a><a id="L2873" href="#L2873">2873</a><a id="L2874" href="#L2874">2874</a><a id="L2875" href="#L2875">2875</a><a id="L2876" href="#L2876">2876</a><a id="L2877" href="#L2877">2877</a><a id="L2878" href="#L2878">2878</a><a id="L2879" href="#L2879">2879</a><a id="L2880" href="#L2880">2880</a><a id="L2881" href="#L2881">2881</a><a id="L2882" href="#L2882">2882</a><a id="L2883" href="#L2883">2883</a><a id="L2884" href="#L2884">2884</a><a id="L2885" href="#L2885">2885</a><a id="L2886" href="#L2886">2886</a><a id="L2887" href="#L2887">2887</a><a id="L2888" href="#L2888">2888</a><a id="L2889" href="#L2889">2889</a><a id="L2890" href="#L2890">2890</a><a id="L2891" href="#L2891">2891</a><a id="L2892" href="#L2892">2892</a><a id="L2893" href="#L2893">2893</a><a id="L2894" href="#L2894">2894</a><a id="L2895" href="#L2895">2895</a><a id="L2896" href="#L2896">2896</a><a id="L2897" href="#L2897">2897</a><a id="L2898" href="#L2898">2898</a><a id="L2899" href="#L2899">2899</a><a id="L2900" href="#L2900">2900</a><a id="L2901" href="#L2901">2901</a><a id="L2902" href="#L2902">2902</a><a id="L2903" href="#L2903">2903</a><a id="L2904" href="#L2904">2904</a><a id="L2905" href="#L2905">2905</a><a id="L2906" href="#L2906">2906</a><a id="L2907" href="#L2907">2907</a><a id="L2908" href="#L2908">2908</a><a id="L2909" href="#L2909">2909</a><a id="L2910" href="#L2910">2910</a><a id="L2911" href="#L2911">2911</a><a id="L2912" href="#L2912">2912</a><a id="L2913" href="#L2913">2913</a><a id="L2914" href="#L2914">2914</a><a id="L2915" href="#L2915">2915</a><a id="L2916" href="#L2916">2916</a><a id="L2917" href="#L2917">2917</a><a id="L2918" href="#L2918">2918</a><a id="L2919" href="#L2919">2919</a><a id="L2920" href="#L2920">2920</a><a id="L2921" href="#L2921">2921</a><a id="L2922" href="#L2922">2922</a><a id="L2923" href="#L2923">2923</a><a id="L2924" href="#L2924">2924</a><a id="L2925" href="#L2925">2925</a><a id="L2926" href="#L2926">2926</a><a id="L2927" href="#L2927">2927</a></td>
<td><td><pre class="sourcecode">
<span class="lc">// Written in the D programming language.</span>

<span class="bc">/**
Classes and functions for handling and transcoding between various encodings.

For cases where the _encoding is known at compile-time, functions are provided
for arbitrary _encoding and decoding of characters, arbitrary transcoding
between strings of different type, as well as validation and sanitization.

Encodings currently supported are UTF-8, UTF-16, UTF-32, ASCII, ISO-8859-1
(also known as LATIN-1), and WINDOWS-1252.
The type AsciiChar represents an ASCII character.
The type AsciiString represents an ASCII character.
The type Latin1Char represents an ISO-8859-1 character.
The type Latin1String represents an ISO-8859-1 character.
The type Windows1252Char represents a Windows-1252 character.
The type Windows1252String represents a Windows-1252 character.

For cases where the _encoding is not known at compile-time, but is known at
run-time, we provide the abstract class EncodingScheme and its subclasses.
To construct a run-time encoder/decoder, one does e.g.

----------------------------------------------------
    auto e = EncodingScheme.create("utf-8");
----------------------------------------------------

This library supplies EncodingScheme subclasses for ASCII, ISO-8859-1
(also known as LATIN-1), WINDOWS-1252, UTF-8, and (on little-endian
architectures) UTF-16LE and UTF-32LE; or (on big-endian architectures)
UTF-16BE and UTF-32BE.

This library provides a mechanism whereby other modules may add EncodingScheme
subclasses for any other encoding.

Authors: Janice Caron

Date: 2008.02.27 - 2008.05.07

License: Public Domain


Macros:
    WIKI=Phobos/StdEncoding
*/</span>

<span class="d Compound"><span class="d Module"><span class="k">module</span> <span class="i">std</span>.<span class="i">encoding</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">std</span>.<span class="i">string</span>;</span>
<span class="d Import"><span class="k">import</span> <span class="i">std</span>.<span class="i">traits</span>;</span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span><span class="t Array">[]</span> <span class="i">validStrings</span> =
    <span class="e ArrayInit">[
        <span class="lc">// Plain ASCII</span>
        <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"hello"</span></span></span>,

        <span class="lc">// First possible sequence of a certain length</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x00</span></span> ]</span>,                       <span class="lc">// U+00000000   one byte</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xC2</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,                 <span class="lc">// U+00000080   two bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xE0</span></span>, <span class="e Int"><span class="n">0xA0</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,           <span class="lc">// U+00000800   three bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF0</span></span>, <span class="e Int"><span class="n">0x90</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,     <span class="lc">// U+00010000   three bytes</span>

        <span class="lc">// Last possible sequence of a certain length</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x7F</span></span> ]</span>,                       <span class="lc">// U+0000007F   one byte</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xDF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                 <span class="lc">// U+000007FF   two bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,           <span class="lc">// U+0000FFFF   three bytes</span>

        <span class="lc">// Other boundary conditions</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0x9F</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,           <span class="lc">// U+0000D7FF   Last character before surrogates</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEE</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,           <span class="lc">// U+0000E000   First character after surrogates</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBD</span></span> ]</span>,           <span class="lc">// U+0000FFFD   Unicode replacement character</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF4</span></span>, <span class="e Int"><span class="n">0x8F</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,     <span class="lc">// U+0010FFFF   Very last character</span>

        <span class="lc">// Non-character code points</span>
        <span class="bc">/*  NOTE: These are legal in UTF, and may be converted from one UTF to
            another, however they do not represent Unicode characters. These
            code points have been reserved by Unicode as non-character code
            points. They are permissible for data exchange within an
            application, but they are are not permitted to be used as
            characters. Since this module deals with UTF, and not with Unicode
            per se, we choose to accept them here. */</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xDF</span></span>, <span class="e Int"><span class="n">0xBE</span></span> ]</span>,                 <span class="lc">// U+0000FFFE</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xDF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                 <span class="lc">// U+0000FFFF</span>
    ]</span>;</span></span>

    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span><span class="t Array">[]</span> <span class="i">invalidStrings</span> =
    <span class="e ArrayInit">[
        <span class="lc">// First possible sequence of a certain length, but greater than U+10FFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF8</span></span>, <span class="e Int"><span class="n">0x88</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,           <span class="lc">// U+00200000   five bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFC</span></span>, <span class="e Int"><span class="n">0x84</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,     <span class="lc">// U+04000000   six bytes</span>

        <span class="lc">// Last possible sequence of a certain length, but greater than U+10FFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF7</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                 <span class="lc">// U+001FFFFF   four bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFB</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,           <span class="lc">// U+03FFFFFF   five bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFD</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,     <span class="lc">// U+7FFFFFFF   six bytes</span>

        <span class="lc">// Other boundary conditions</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF4</span></span>, <span class="e Int"><span class="n">0x90</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,                 <span class="lc">// U+00110000   First code</span>
                                                    <span class="lc">// point after last character</span>

        <span class="lc">// Unexpected continuation bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x80</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xBF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x9F</span></span>, <span class="e Int"><span class="n">0xA0</span></span> ]</span>,

        <span class="lc">// Lonely start bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xC0</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xCF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xC0</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xCF</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xD0</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xDF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xD0</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xDF</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xE0</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xE0</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xEF</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF0</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF1</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF2</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF3</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF4</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF5</span></span> ]</span>,   <span class="lc">// If this were legal it would start a character &gt; U+10FFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF6</span></span> ]</span>,   <span class="lc">// If this were legal it would start a character &gt; U+10FFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF7</span></span> ]</span>,   <span class="lc">// If this were legal it would start a character &gt; U+10FFFF</span>

        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,             <span class="lc">// Three byte sequence with third byte missing</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF7</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,       <span class="lc">// Four byte sequence with fourth byte missing</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xEF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xF7</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,   <span class="lc">// Concatenation of the above</span>

        <span class="lc">// Impossible bytes</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF8</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF9</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFA</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFB</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFC</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFD</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFE</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xF8</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xF9</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFA</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFB</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFC</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFD</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFE</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0x20</span></span>, <span class="e Int"><span class="n">0xFF</span></span>, <span class="e Int"><span class="n">0x20</span></span> ]</span>,

        <span class="lc">// Overlong sequences, all representing U+002F</span>
        <span class="bc">/*  With a safe UTF-8 decoder, all of the following five overlong
            representations of the ASCII character slash ("/") should be
            rejected like a malformed UTF-8 sequence */</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xC0</span></span>, <span class="e Int"><span class="n">0xAF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xE0</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0xAF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF0</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0xAF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF8</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0xAF</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFC</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0xAF</span></span> ]</span>,

        <span class="lc">// Maximum overlong sequences</span>
        <span class="bc">/*  Below you see the highest Unicode value that is still resulting in
            an overlong sequence if represented with the given number of bytes.
            This is a boundary test for safe UTF-8 decoders. All five
            characters should be rejected like malformed UTF-8 sequences. */</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xC1</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                             <span class="lc">// U+0000007F</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xE0</span></span>, <span class="e Int"><span class="n">0x9F</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                       <span class="lc">// U+000007FF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF0</span></span>, <span class="e Int"><span class="n">0x8F</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,                 <span class="lc">// U+0000FFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF8</span></span>, <span class="e Int"><span class="n">0x87</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,           <span class="lc">// U+001FFFFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFC</span></span>, <span class="e Int"><span class="n">0x83</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,     <span class="lc">// U+03FFFFFF</span>

        <span class="lc">// Overlong representation of the NUL character</span>
        <span class="bc">/*  The following five sequences should also be rejected like malformed
            UTF-8 sequences and should not be treated like the ASCII NUL
            character. */</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xC0</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xE0</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF0</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xF8</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xFC</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,

        <span class="lc">// Illegal code positions</span>
        <span class="bc">/*  The following UTF-8 sequences should be rejected like malformed
            sequences, because they never represent valid ISO 10646 characters
            and a UTF-8 decoder that accepts them might introduce security
            problems comparable to overlong UTF-8 sequences. */</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xA0</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,       <span class="lc">// U+D800</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xAD</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,       <span class="lc">// U+DB7F</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xAE</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,       <span class="lc">// U+DB80</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xAF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,       <span class="lc">// U+DBFF</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xB0</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,       <span class="lc">// U+DC00</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xBE</span></span>, <span class="e Int"><span class="n">0x80</span></span> ]</span>,       <span class="lc">// U+DF80</span>
        <span class="e ArrayInit">[ <span class="e Int"><span class="n">0xED</span></span>, <span class="e Int"><span class="n">0xBF</span></span>, <span class="e Int"><span class="n">0xBF</span></span> ]</span>,       <span class="lc">// U+DFFF</span>
    ]</span>;</span></span>

    <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">sanitizedStrings</span> =
    <span class="e ArrayInit">[
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,
        <span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">"\uFFFD\uFFFD\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,
        <span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,
        <span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">" \uFFFD "</span></span>,
        <span class="e String"><span class="sl">" \uFFFD "</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
        <span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,<span class="e String"><span class="sl">"\uFFFD"</span></span>,
    ]</span>;</span></span>

    <span class="lc">// Make sure everything that should be valid, is</span>
    <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">a</span></span></span>;<span class="e Identifier"><span class="i">validStrings</span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">a</span></span></span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>,<span class="e Cat"><span class="e String"><span class="sl">"Failed to validate: "</span></span>~<span class="e Call"><span class="e Identifier"><span class="i">makeReadable</span></span>(<span class="i">s</span>)</span></span>)</span>;</span>
    }</span></span>

    <span class="lc">// Make sure everything that shouldn't be valid, isn't</span>
    <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">a</span></span></span>;<span class="e Identifier"><span class="i">invalidStrings</span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">a</span></span></span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValid</span></span></span>(<span class="i">s</span>)</span>,<span class="e Cat"><span class="e String"><span class="sl">"Incorrectly validated: "</span></span>~<span class="e Call"><span class="e Identifier"><span class="i">makeReadable</span></span>(<span class="i">s</span>)</span></span>)</span>;</span>
    }</span></span>

    <span class="lc">// Make sure we can sanitize everything bad</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">invalidStrings</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">sanitizedStrings</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)</span>;</span>
    <span class="s For"><span class="k">for</span>(<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Dot"><span class="e Identifier"><span class="i">invalidStrings</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span> = <span class="e Index"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">invalidStrings</span></span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">t</span> = <span class="e Call"><span class="e Identifier"><span class="i">sanitize</span></span>(<span class="i">s</span>)</span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">t</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">t</span></span> == <span class="e Index"><span class="e Identifier"><span class="i">sanitizedStrings</span></span>[<span class="e Identifier"><span class="i">i</span></span>]</span></span>)</span>;</span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">u</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">t</span></span></span>;</span></span>
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">validStrings</span></span> ~= <span class="e Identifier"><span class="i">u</span></span></span>;</span>
    }</span></span>

    <span class="lc">// Make sure all transcodings work in both directions, using both forward</span>
    <span class="lc">// and reverse iteration</span>
    <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">a</span></span></span>;<span class="e Identifier"><span class="i">validStrings</span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">a</span></span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s2</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">wstring</span></span> <span class="i">ws</span>, <span class="i">ws2</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">dstring</span></span> <span class="i">ds</span>, <span class="i">ds2</span>;</span></span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">ws</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ws</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ws</span>,<span class="i">s2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">s2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">ds</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ds</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ds</span>,<span class="i">s2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">s2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ws</span>,<span class="i">s</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">ws2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ws</span></span> == <span class="e Identifier"><span class="i">ws2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ws</span>,<span class="i">ds</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ds</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ds</span>,<span class="i">ws2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ws</span></span> == <span class="e Identifier"><span class="i">ws2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ds</span>,<span class="i">s</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">ds2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ds</span></span> == <span class="e Identifier"><span class="i">ds2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ds</span>,<span class="i">ws</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ws</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">ws</span>,<span class="i">ds2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ds</span></span> == <span class="e Identifier"><span class="i">ds2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">s</span>,<span class="i">ws</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ws</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ws</span>,<span class="i">s2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">s2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">s</span>,<span class="i">ds</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ds</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ds</span>,<span class="i">s2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">s2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ws</span>,<span class="i">s</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">s</span>,<span class="i">ws2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ws</span></span> == <span class="e Identifier"><span class="i">ws2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ws</span>,<span class="i">ds</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ds</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ds</span>,<span class="i">ws2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ws</span></span> == <span class="e Identifier"><span class="i">ws2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ds</span>,<span class="i">s</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">s</span>,<span class="i">ds2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ds</span></span> == <span class="e Identifier"><span class="i">ds2</span></span></span>)</span>;</span>

        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ds</span>,<span class="i">ws</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">ws</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcodeReverse</span></span>(<span class="i">ws</span>,<span class="i">ds2</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">ds</span></span> == <span class="e Identifier"><span class="i">ds2</span></span></span>)</span>;</span>
    }</span></span>

    <span class="lc">// Make sure the non-UTF encodings work too</span>
    <span class="s Scope"><span class="s Compound">{
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">s</span> = <span class="e String"><span class="sl">"\u20AC100"</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Windows1252String</span></span> <span class="i">t</span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">t</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">t</span></span> == <span class="e ArrayLiteral">[<span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">Windows1252Char</span></span>)<span class="e Int"><span class="n">0x80</span></span></span>, <span class="e Char"><span class="cl">'1'</span></span>, <span class="e Char"><span class="cl">'0'</span></span>, <span class="e Char"><span class="cl">'0'</span></span>]</span></span>)</span>;</span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">u</span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">u</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">u</span></span></span>)</span>;</span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Latin1String</span></span> <span class="i">v</span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">s</span>,<span class="i">v</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">v</span></span></span> == <span class="e String"><span class="sl">"?100"</span></span></span>)</span>;</span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">AsciiString</span></span> <span class="i">w</span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">transcode</span></span>(<span class="i">v</span>,<span class="i">w</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)<span class="e Identifier"><span class="i">w</span></span></span> == <span class="e String"><span class="sl">"?100"</span></span></span>)</span>;</span>
    }</span></span>
    
    <span class="lc">// Make sure we can count properly</span>
    <span class="s Scope"><span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span>(<span class="cl">'A'</span>)</span> == <span class="e Int"><span class="n">1</span></span></span>)</span>;</span>
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span>(<span class="cl">'\u00E3'</span>)</span> == <span class="e Int"><span class="n">2</span></span></span>)</span>;</span>
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span>(<span class="cl">'\u2028'</span>)</span> == <span class="e Int"><span class="n">3</span></span></span>)</span>;</span>
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span>(<span class="cl">'\U0010FFF0'</span>)</span> == <span class="e Int"><span class="n">4</span></span></span>)</span>;</span>
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">wchar</span></span></span>)</span>(<span class="cl">'A'</span>)</span> == <span class="e Int"><span class="n">1</span></span></span>)</span>;</span>
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">wchar</span></span></span>)</span>(<span class="cl">'\U0010FFF0'</span>)</span> == <span class="e Int"><span class="n">2</span></span></span>)</span>;</span>
    }</span></span>
    
    <span class="lc">// Make sure we can write into mutable arrays</span>
    <span class="s Scope"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[<span class="e Int"><span class="n">4</span></span>]</span> <span class="i">buffer</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">encode</span></span>(<span class="k">cast</span>(<span class="k">dchar</span>)<span class="cl">'\u00E3'</span>,<span class="i">buffer</span>)</span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Int"><span class="n">2</span></span></span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> == <span class="e Int"><span class="n">0xC3</span></span></span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e Int"><span class="n">1</span></span>]</span> == <span class="e Int"><span class="n">0xA3</span></span></span>)</span>;</span>
    }</span></span>
}</span></span></span>

<span class="lc">//=============================================================================</span>

<span class="bc">/* A simple growable buffer for fast appending */</span>
<span class="d StorageClass"><span class="k">deprecated</span> <span class="d Template"><span class="d Compound"><span class="d Struct"><span class="k">struct</span> <span class="i">Buffer</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t TemplateInstance"><span class="i">Mutable</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span> <span class="i">T</span>;</span></span>

    <span class="d Protection"><span class="k">private</span>
    <span class="d Compound">{
        <span class="d Variables"><span class="t Identifier"><span class="i">T</span></span><span class="t Array">[]</span> <span class="i">buffer</span>;</span>
        <span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">index</span>;</span>

        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">reserve</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">uint</span></span> <span class="i">spaceNeeded</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">bufferLength</span> = <span class="e Dot"><span class="e Identifier"><span class="i">buffer</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
            <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">bufferLength</span></span> &lt; <span class="e Plus"><span class="e Identifier"><span class="i">index</span></span> + <span class="e Identifier"><span class="i">spaceNeeded</span></span></span></span>)
            <span class="s Compound">{
                <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">bufferLength</span></span> == <span class="e Int"><span class="n">0</span></span></span>) <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">bufferLength</span></span> = <span class="e Int"><span class="n">16</span></span></span>;</span></span>
                <span class="s While"><span class="k">while</span> (<span class="e Rel"><span class="e Identifier"><span class="i">bufferLength</span></span> &lt; <span class="e Plus"><span class="e Identifier"><span class="i">index</span></span> + <span class="e Identifier"><span class="i">spaceNeeded</span></span></span></span>) <span class="s Expression"><span class="e LShiftAssign"><span class="e Identifier"><span class="i">bufferLength</span></span> &lt;&lt;= <span class="e Int"><span class="n">2</span></span></span>;</span></span>
                <span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">buffer</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> = <span class="e Identifier"><span class="i">bufferLength</span></span></span>;</span>
            }</span></span>
        }</span></span></span>
    }</span></span>

    <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">opCatAssign</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span> <span class="lc">// Append a single character</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reserve</span></span>(<span class="n">1</span>)</span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e PostIncr"><span class="e Identifier"><span class="i">index</span></span>++</span>]</span> = <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">opCatAssign</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">a</span></span>)</span> <span class="lc">// Append an array of characters</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">reserve</span></span>(<span class="i">a</span>.<span class="i">length</span>)</span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e Identifier"><span class="i">index</span></span>..<span class="e Plus"><span class="e Identifier"><span class="i">index</span></span>+<span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">a</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">index</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">T</span></span><span class="t Array">[]</span> <span class="i">toArray</span><span class="o Parameters">()</span> <span class="lc">// Return the buffer, and reset it</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Slice"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">index</span></span>]</span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">buffer</span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">index</span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">t</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">T</span></span>)</span><span class="t Array">[]</span> <span class="i">toIArray</span><span class="o Parameters">()</span> <span class="lc">// Return the buffer as an invariant array, and reset it</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">T</span></span>)</span><span class="t Array">[]</span>)<span class="e Paren">(<span class="e Slice"><span class="e Identifier"><span class="i">buffer</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">index</span></span>]</span>)</span></span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">buffer</span></span> = <span class="e Null"><span class="k">null</span></span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">index</span></span> = <span class="e Int"><span class="n">0</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">t</span></span>;</span>
    }</span></span></span>
}</span></span></span></span></span>

<span class="lc">//=============================================================================</span>

<span class="bc">/** Special value returned by safeDecode */</span>
<span class="d StorageClass"><span class="k">enum</span> <span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">INVALID_SEQUENCE</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Int"><span class="n">0xFFFFFFFF</span></span></span>;</span></span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderFunctions</span><span class="o TemplateParameters">()</span>
<span class="d Compound">{
    <span class="lc">// Various forms of read</span>

    <span class="d Template"><span class="k">template</span> <span class="i">ReadFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canRead</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>;</span> }</span></span></span>
        <span class="d Function"><span class="t Identifier"><span class="i">E</span></span> <span class="i">peek</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">0</span></span>]</span>;</span> }</span></span></span>
        <span class="d Function"><span class="t Identifier"><span class="i">E</span></span> <span class="i">read</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">E</span></span> <span class="i">t</span> = <span class="e Index"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">0</span></span>]</span>;</span></span> <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">1</span></span>..<span class="e Dollar">$</span>]</span></span>;</span> <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">t</span></span>;</span> }</span></span></span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">ReverseReadFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canRead</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>;</span> }</span></span></span>
        <span class="d Function"><span class="t Identifier"><span class="i">E</span></span> <span class="i">peek</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Int"><span class="n">1</span></span></span>]</span>;</span> }</span></span></span>
        <span class="d Function"><span class="t Identifier"><span class="i">E</span></span> <span class="i">read</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">E</span></span> <span class="i">t</span> = <span class="e Index"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Int"><span class="n">1</span></span></span>]</span>;</span></span> <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Int"><span class="n">1</span></span></span>]</span></span>;</span> <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">t</span></span>;</span> }</span></span></span>
    }</span></span>

    <span class="lc">// Various forms of Write</span>

    <span class="d Template"><span class="k">template</span> <span class="i">WriteToString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Variables"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">s</span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">write</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">s</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span> }</span></span></span>
    }</span></span>
    
    <span class="d Template"><span class="k">template</span> <span class="i">WriteToArray</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
            <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">write</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> = <span class="e Identifier"><span class="i">c</span></span></span>;</span> <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">array</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Int"><span class="n">1</span></span>..<span class="e Dollar">$</span>]</span></span>;</span> }</span></span></span>
    }</span></span>

    <span class="d StorageClass"><span class="k">deprecated</span> <span class="d Template"><span class="k">template</span> <span class="i">WriteToBuffer</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">write</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">buffer</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span> }</span></span></span>
    }</span></span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">WriteToDelegate</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">write</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">c</span>)</span>;</span> }</span></span></span>
    }</span></span>

    <span class="lc">// Functions we will export</span>

    <span class="d Template"><span class="k">template</span> <span class="i">EncodeViaWrite</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">encodeViaWrite</span></span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">encodeViaWrite</span></span>(<span class="i">c</span>)</span>;</span> }</span></span></span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">SkipViaRead</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">skipViaRead</span></span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skip</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">skipViaRead</span></span>()</span>;</span> }</span></span></span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">DecodeViaRead</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">decodeViaRead</span></span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">decodeViaRead</span></span>()</span>;</span> }</span></span></span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">SafeDecodeViaRead</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">safeDecodeViaRead</span></span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">safeDecodeViaRead</span></span>()</span>;</span> }</span></span></span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">DecodeReverseViaRead</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">decodeReverseViaRead</span></span>;</span>
        <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverse</span><span class="o Parameters">()</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">decodeReverseViaRead</span></span>()</span>;</span> }</span></span></span>
    }</span></span>

    <span class="lc">// Encoding to different destinations</span>

    <span class="d Template"><span class="k">template</span> <span class="i">EncodeToString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">WriteToString</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeViaWrite</span></span>;</span>
    }</span></span>
    
    <span class="d Template"><span class="k">template</span> <span class="i">EncodeToArray</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
            <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">WriteToArray</span></span>;</span>
            <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeViaWrite</span></span>;</span>
    }</span></span>

    <span class="d StorageClass"><span class="k">deprecated</span> <span class="d Template"><span class="k">template</span> <span class="i">EncodeToBuffer</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">WriteToBuffer</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeViaWrite</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">EncodeToDelegate</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">WriteToDelegate</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeViaWrite</span></span>;</span>
    }</span></span>

    <span class="lc">// Decoding functions</span>

    <span class="d Template"><span class="k">template</span> <span class="i">SkipFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">ReadFromString</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">SkipViaRead</span></span>;</span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">DecodeFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">ReadFromString</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">DecodeViaRead</span></span>;</span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">SafeDecodeFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">ReadFromString</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">SafeDecodeViaRead</span></span>;</span>
    }</span></span>

    <span class="d Template"><span class="k">template</span> <span class="i">DecodeReverseFromString</span><span class="o TemplateParameters">()</span>
    <span class="d Compound">{
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">ReverseReadFromString</span></span>;</span>
        <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">DecodeReverseViaRead</span></span>;</span>
    }</span></span>

    <span class="lc">//=========================================================================</span>

    <span class="lc">// Below are the functions we will ultimately expose to the user</span>
    
    <span class="d Function"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeToString</span></span> <span class="i">e</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>)</span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">s</span></span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">array</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
            <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeToArray</span></span> <span class="i">e</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">deprecated</span> <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t TemplateInstance"><span class="i">Buffer</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span> <span class="i">buffer</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeToBuffer</span></span> <span class="i">e</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span></span>
    
    <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">void</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncodeToDelegate</span></span> <span class="i">e</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skip</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">SkipFromString</span></span> <span class="i">e</span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">skip</span></span></span>()</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">DecodeFromString</span></span> <span class="i">e</span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>()</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">SafeDecodeFromString</span></span> <span class="i">e</span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>()</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverse</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">DecodeReverseFromString</span></span> <span class="i">e</span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">e</span></span>.<span class="e Identifier"><span class="i">decodeReverse</span></span></span>()</span>;</span>
    }</span></span></span>
}</span></span>

<span class="lc">//=========================================================================</span>

<span class="d Template"><span class="d Compound"><span class="d Struct"><span class="k">struct</span> <span class="i">CodePoints</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span>
<span class="d Compound">{
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span>;</span>

    <span class="d StorageClass"><span class="k">static</span> <span class="d Function"><span class="t Identifier"><span class="i">CodePoints</span></span> <span class="i">opCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">CodePoints</span></span> <span class="i">codePoints</span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">codePoints</span></span>.<span class="e Identifier"><span class="i">s</span></span></span> = <span class="e Identifier"><span class="i">s</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">codePoints</span></span>;</span>
    }</span></span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApply</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">dchar</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">decode</span></span>(<span class="i">s</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApply</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">uint</span></span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">dchar</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">len</span> = <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">decode</span></span>(<span class="i">s</span>)</span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">j</span> = <span class="e Identifier"><span class="i">i</span></span>;</span></span> <span class="lc">// We don't want the delegate corrupting i</span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">j</span>,<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
            <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">i</span></span> += <span class="e Minus"><span class="e Identifier"><span class="i">len</span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span></span>;</span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApplyReverse</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">dchar</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">decodeReverse</span></span>(<span class="i">s</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApplyReverse</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">uint</span></span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t Integral"><span class="k">dchar</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">decodeReverse</span></span>(<span class="i">s</span>)</span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span> = <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">i</span>,<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>
}</span></span></span></span>

<span class="d Template"><span class="d Compound"><span class="d Struct"><span class="k">struct</span> <span class="i">CodeUnits</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span>
<span class="d Compound">{
    <span class="d Variables"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">s</span>;</span>

    <span class="d StorageClass"><span class="k">static</span> <span class="d Function"><span class="t Identifier"><span class="i">CodeUnits</span></span> <span class="i">opCall</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">d</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">d</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">CodeUnits</span></span> <span class="i">codeUnits</span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Dot"><span class="e Identifier"><span class="i">codeUnits</span></span>.<span class="e Identifier"><span class="i">s</span></span></span> = <span class="e Call"><span class="e TemplateInstance"><span class="i">encode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>(<span class="i">d</span>)</span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">codeUnits</span></span>;</span>
    }</span></span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApply</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">E</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span></span>;<span class="e Identifier"><span class="i">s</span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">opApplyReverse</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Identifier"><span class="i">E</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">result</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach_reverse</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span></span>;<span class="e Identifier"><span class="i">s</span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">result</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">dg</span></span>(<span class="i">c</span>)</span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">result</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">result</span></span>;</span>
    }</span></span></span>
}</span></span></span></span>

<span class="lc">//=============================================================================</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span>
<span class="d Compound">{
    <span class="d StaticAssert"><span class="k">static</span> <span class="k">assert</span>(<span class="e Bool"><span class="k">false</span></span>,<span class="e Cat"><span class="e String"><span class="sl">"Cannot instantiate EncoderInstance for type "</span></span>
        ~ <span class="e Dot"><span class="e Identifier"><span class="i">E</span></span>.<span class="e Identifier"><span class="i">stringof</span></span></span></span>);</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          ASCII</span>
<span class="lc">//=============================================================================</span>

<span class="d Typedef"><span class="k">typedef</span> <span class="d Variables"><span class="t Integral"><span class="k">char</span></span> <span class="i">AsciiChar</span>;</span></span> <span class="lc">///</span>
<span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">AsciiChar</span></span>)</span><span class="t Array">[]</span> <span class="i">AsciiString</span>;</span></span> <span class="lc">///</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Identifier"><span class="i">AsciiChar</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Identifier"><span class="i">AsciiString</span></span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"ASCII"</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">AsciiChar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>;</span>
    }</span></span></span>
    
    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">1</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">canEncode</span></span></span>(<span class="i">c</span>)</span>) <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Char"><span class="cl">'?'</span></span></span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="i">AsciiChar</span>)<span class="i">c</span>)</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">read</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span> ? <span class="e Identifier"><span class="i">c</span></span> : <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">read</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">EString</span></span>)<span class="e Paren">(<span class="e String"><span class="sl">"?"</span></span>)</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          ISO-8859-1</span>
<span class="lc">//=============================================================================</span>

<span class="d Typedef"><span class="k">typedef</span> <span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span> <span class="i">Latin1Char</span>;</span></span> <span class="lc">///</span>
<span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Latin1Char</span></span>)</span><span class="t Array">[]</span> <span class="i">Latin1String</span>;</span></span> <span class="lc">///</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Identifier"><span class="i">Latin1Char</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Identifier"><span class="i">Latin1String</span></span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"ISO-8859-1"</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x100</span></span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">Latin1Char</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">1</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">canEncode</span></span></span>(<span class="i">c</span>)</span>) <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Char"><span class="cl">'?'</span></span></span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="i">Latin1Char</span>)<span class="i">c</span>)</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">read</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">read</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">read</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">EString</span></span>)<span class="e Paren">(<span class="e String"><span class="sl">"?"</span></span>)</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          WINDOWS-1252</span>
<span class="lc">//=============================================================================</span>

<span class="d Typedef"><span class="k">typedef</span> <span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span> <span class="i">Windows1252Char</span>;</span></span> <span class="lc">///</span>
<span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Windows1252Char</span></span>)</span><span class="t Array">[]</span> <span class="i">Windows1252String</span>;</span></span> <span class="lc">///</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Identifier"><span class="i">Windows1252String</span></span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"windows-1252"</span></span>;</span>
    }</span></span></span>

    <span class="d Variables"><span class="t Identifier"><span class="i">wstring</span></span> <span class="i">charMap</span> =
        <span class="e String"><span class="sl">"\u20AC\uFFFD\u201A\u0192\u201E\u2026\u2020\u2021"</span>
        <span class="sl">"\u02C6\u2030\u0160\u2039\u0152\uFFFD\u017D\uFFFD"</span>
        <span class="sl">"\uFFFD\u2018\u2019\u201C\u201D\u2022\u2103\u2014"</span>
        <span class="sl">"\u02DC\u2122\u0161\u203A\u0153\uFFFD\u017E\u0178"</span></span>
    ;</span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span> || <span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xA0</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt;<span class="e Int"><span class="n">0x100</span></span></span></span>)</span></span>) <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xFFFD</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">d</span></span></span>;<span class="e Identifier"><span class="i">charMap</span></span>) <span class="s Compound">{ <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">d</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span> }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">Windows1252Char</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xA0</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Paren">(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">charMap</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">c</span></span>-<span class="e Int"><span class="n">0x80</span></span></span>]</span> != <span class="e Int"><span class="n">0xFFFD</span></span></span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">1</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span> || <span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xA0</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt;<span class="e Int"><span class="n">0x100</span></span></span></span>)</span></span>) <span class="s Compound">{}</span>
        <span class="k">else</span> <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xFFFD</span></span></span>) <span class="s Compound">{ <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Char"><span class="cl">'?'</span></span></span>;</span> }</span>
        <span class="k">else</span>
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span>;</span></span>
            <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">i</span></span>,<span class="o Parameter"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">d</span></span></span>;<span class="e Identifier"><span class="i">charMap</span></span>)
            <span class="s Compound">{
                <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">d</span></span></span>)
                <span class="s Compound">{
                    <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">n</span></span> = <span class="e Identifier"><span class="i">i</span></span></span>;</span>
                    <span class="s Break"><span class="k">break</span>;</span>
                }</span></span>
            }</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Cond"><span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Sign">-<span class="e Int"><span class="n">1</span></span></span></span> ? <span class="e Char"><span class="cl">'?'</span></span> : <span class="e Plus"><span class="e Int"><span class="n">0x80</span></span> + <span class="e Identifier"><span class="i">n</span></span></span></span></span>;</span>
        }</span></span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="i">Windows1252Char</span>)<span class="i">c</span>)</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Windows1252Char</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x80</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xA0</span></span></span></span>)</span> ? <span class="e Index"><span class="e Identifier"><span class="i">charMap</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">c</span></span>-<span class="e Int"><span class="n">0x80</span></span></span>]</span> : <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Windows1252Char</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">d</span> = <span class="e Cond"><span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x80</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xA0</span></span></span></span>)</span> ? <span class="e Index"><span class="e Identifier"><span class="i">charMap</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">c</span></span>-<span class="e Int"><span class="n">0x80</span></span></span>]</span> : <span class="e Identifier"><span class="i">c</span></span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Equal"><span class="e Identifier"><span class="i">d</span></span> == <span class="e Int"><span class="n">0xFFFD</span></span></span> ? <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span> : <span class="e Identifier"><span class="i">d</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">Windows1252Char</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x80</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xA0</span></span></span></span>)</span> ? <span class="e Index"><span class="e Identifier"><span class="i">charMap</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">c</span></span>-<span class="e Int"><span class="n">0x80</span></span></span>]</span> : <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">EString</span></span>)<span class="e Paren">(<span class="e String"><span class="sl">"?"</span></span>)</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          UTF-8</span>
<span class="lc">//=============================================================================</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Integral"><span class="k">char</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">char</span></span>)</span><span class="t Array">[]</span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"UTF-8"</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">char</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Paren">(<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xC0</span></span></span> || <span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xC2</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xF5</span></span></span></span>)</span></span>)</span>;</span>
    }</span></span></span>

    <span class="d Variables"><span class="t Integral"><span class="k">byte</span></span><span class="t Array">[<span class="e Int"><span class="n">128</span></span>]</span> <span class="i">tailTable</span> =
    <span class="e ArrayInit">[
        <span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,
        <span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,
        <span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,
        <span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,<span class="e Int"><span class="n">0</span></span>,
        <span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,
        <span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,<span class="e Int"><span class="n">1</span></span>,
        <span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,<span class="e Int"><span class="n">2</span></span>,
        <span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">3</span></span>,<span class="e Int"><span class="n">4</span></span>,<span class="e Int"><span class="n">4</span></span>,<span class="e Int"><span class="n">4</span></span>,<span class="e Int"><span class="n">4</span></span>,<span class="e Int"><span class="n">5</span></span>,<span class="e Int"><span class="n">5</span></span>,<span class="e Int"><span class="n">6</span></span>,<span class="e Int"><span class="n">0</span></span>,
    ]</span>;</span>

    <span class="d Protection"><span class="k">private</span> <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">tails</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">char</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x80</span></span></span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e Identifier"><span class="i">tailTable</span></span>[<span class="e Minus"><span class="e Identifier"><span class="i">c</span></span>-<span class="e Int"><span class="n">0x80</span></span></span>]</span>;</span>
    }</span></span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">1</span></span>;</span></span>
                <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x800</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">2</span></span>;</span></span>
                <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x10000</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">3</span></span>;</span></span>
                <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">4</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)<span class="i">c</span>)</span>;</span>
        }</span>
        <span class="k">else</span> <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x800</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &gt;&gt; <span class="n">6</span>) + <span class="n">0xC0</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
        }</span>
        <span class="k">else</span> <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x10000</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &gt;&gt; <span class="n">12</span>) + <span class="n">0xE0</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)(((<span class="i">c</span> &gt;&gt; <span class="n">6</span>) &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
        }</span>
        <span class="k">else</span>
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &gt;&gt; <span class="n">18</span>) + <span class="n">0xF0</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)(((<span class="i">c</span> &gt;&gt; <span class="n">12</span>) &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)(((<span class="i">c</span> &gt;&gt; <span class="n">6</span>) &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">char</span>)((<span class="i">c</span> &amp; <span class="n">0x3F</span>) + <span class="n">0x80</span>))</span>;</span>
        }</span></span></span></span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xC0</span></span></span>) <span class="s Return"><span class="k">return</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">tails</span></span>(<span class="i">c</span>)</span>;</span></span>
        <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Identifier"><span class="i">n</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
        }</span></span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xC0</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">tails</span></span>(<span class="i">c</span>)</span>;</span></span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Minus"><span class="e Paren">(<span class="e LShift"><span class="e Int"><span class="n">1</span></span> &lt;&lt; <span class="e Paren">(<span class="e Minus"><span class="e Int"><span class="n">6</span></span> - <span class="e Identifier"><span class="i">n</span></span></span>)</span></span>)</span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
        <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Identifier"><span class="i">n</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Plus"><span class="e Paren">(<span class="e LShift"><span class="e Identifier"><span class="i">c</span></span> &lt;&lt; <span class="e Int"><span class="n">6</span></span></span>)</span> + <span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">read</span></span> &amp; <span class="e Int"><span class="n">0x3F</span></span></span>)</span></span></span>;</span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">tails</span></span>(<span class="i">c</span>)</span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Int"><span class="n">0</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>

        <span class="s If"><span class="k">if</span> (<span class="e Not">!<span class="e Identifier"><span class="i">canRead</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">d</span> = <span class="e Identifier"><span class="i">peek</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">bool</span></span> <span class="i">err</span> =
        <span class="e Paren">(
            <span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e OrOr"><span class="e Paren">(<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xC2</span></span></span>)</span>                              <span class="lc">// fail overlong 2-byte sequences</span>
        ||  <span class="e Paren">(<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt; <span class="e Int"><span class="n">0xF4</span></span></span>)</span></span>                              <span class="lc">// fail overlong 4-6-byte sequences</span>
        ||  <span class="e Paren">(<span class="e AndAnd"><span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Int"><span class="n">0xE0</span></span></span> &amp;&amp; <span class="e Paren">(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Int"><span class="n">0xE0</span></span></span>)</span> == <span class="e Int"><span class="n">0x80</span></span></span>)</span></span>)</span></span>     <span class="lc">// fail overlong 3-byte sequences</span>
        ||  <span class="e Paren">(<span class="e AndAnd"><span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Int"><span class="n">0xED</span></span></span> &amp;&amp; <span class="e Paren">(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Int"><span class="n">0xE0</span></span></span>)</span> == <span class="e Int"><span class="n">0xA0</span></span></span>)</span></span>)</span></span>     <span class="lc">// fail surrogates</span>
        ||  <span class="e Paren">(<span class="e AndAnd"><span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Int"><span class="n">0xF0</span></span></span> &amp;&amp; <span class="e Paren">(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Int"><span class="n">0xF0</span></span></span>)</span> == <span class="e Int"><span class="n">0x80</span></span></span>)</span></span>)</span></span>     <span class="lc">// fail overlong 4-byte sequences</span>
        ||  <span class="e Paren">(<span class="e AndAnd"><span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Int"><span class="n">0xF4</span></span></span> &amp;&amp; <span class="e Paren">(<span class="e Rel"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Int"><span class="n">0xF0</span></span></span>)</span> &gt;= <span class="e Int"><span class="n">0x90</span></span></span>)</span></span>)</span></span>     <span class="lc">// fail code points &gt; 0x10FFFF</span>
        )</span>;</span></span>

        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Minus"><span class="e Paren">(<span class="e LShift"><span class="e Int"><span class="n">1</span></span> &lt;&lt; <span class="e Paren">(<span class="e Minus"><span class="e Int"><span class="n">6</span></span> - <span class="e Identifier"><span class="i">n</span></span></span>)</span></span>)</span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span>
        <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Identifier"><span class="i">n</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>)
        <span class="s Compound">{
            <span class="s If"><span class="k">if</span> (<span class="e Not">!<span class="e Identifier"><span class="i">canRead</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">d</span></span> = <span class="e Identifier"><span class="i">peek</span></span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Int"><span class="n">0xC0</span></span></span>)</span> != <span class="e Int"><span class="n">0x80</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Plus"><span class="e Paren">(<span class="e LShift"><span class="e Identifier"><span class="i">c</span></span> &lt;&lt; <span class="e Int"><span class="n">6</span></span></span>)</span> + <span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">read</span></span> &amp; <span class="e Int"><span class="n">0x3F</span></span></span>)</span></span></span>;</span>
        }</span></span>

        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Identifier"><span class="i">err</span></span> ? <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span> : <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">shift</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Int"><span class="n">0x3F</span></span></span>;</span>
        <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Int"><span class="n">4</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">shift</span></span> += <span class="e Int"><span class="n">6</span></span></span>;</span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">d</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">tails</span></span>(<span class="i">d</span>)</span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">mask</span> = <span class="e Cond"><span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Int"><span class="n">0</span></span></span> ? <span class="e Int"><span class="n">0x3F</span></span> : <span class="e Minus"><span class="e Paren">(<span class="e LShift"><span class="e Int"><span class="n">1</span></span> &lt;&lt; <span class="e Paren">(<span class="e Minus"><span class="e Int"><span class="n">6</span></span> - <span class="e Identifier"><span class="i">n</span></span></span>)</span></span>)</span> - <span class="e Int"><span class="n">1</span></span></span></span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">c</span></span> = <span class="e Plus"><span class="e Identifier"><span class="i">c</span></span> + <span class="e Paren">(<span class="e LShift"><span class="e Paren">(<span class="e And"><span class="e Identifier"><span class="i">d</span></span> &amp; <span class="e Identifier"><span class="i">mask</span></span></span>)</span> &lt;&lt; <span class="e Identifier"><span class="i">shift</span></span></span>)</span></span></span>;</span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> != <span class="e Int"><span class="n">0</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"\uFFFD"</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          UTF-16</span>
<span class="lc">//=============================================================================</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Integral"><span class="k">wchar</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">wchar</span></span>)</span><span class="t Array">[]</span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"UTF-16"</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Paren">(<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x10000</span></span></span>)</span> ? <span class="e Int"><span class="n">1</span></span> : <span class="e Int"><span class="n">2</span></span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x10000</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">wchar</span>)<span class="i">c</span>)</span>;</span>
        }</span>
        <span class="k">else</span>
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Minus"><span class="e Identifier"><span class="i">c</span></span> - <span class="e Int"><span class="n">0x10000</span></span></span>;</span></span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">wchar</span>)(<span class="n">0xD800</span> + (<span class="i">n</span> &gt;&gt; <span class="n">10</span>)))</span>;</span>
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">wchar</span>)(<span class="n">0xDC00</span> + (<span class="i">n</span> &amp; <span class="n">0x3FF</span>)))</span>;</span>
        }</span></span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xD800</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span></span>) <span class="s Return"><span class="k">return</span>;</span></span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xD800</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Identifier"><span class="i">c</span></span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">d</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">d</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Plus"><span class="e Plus"><span class="e Int"><span class="n">0x10000</span></span> + <span class="e Paren">(<span class="e LShift"><span class="e Identifier"><span class="i">c</span></span> &lt;&lt; <span class="e Int"><span class="n">10</span></span></span>)</span></span> + <span class="e Identifier"><span class="i">d</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xD800</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Identifier"><span class="i">c</span></span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xDC00</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Not">!<span class="e Identifier"><span class="i">canRead</span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">d</span> = <span class="e Identifier"><span class="i">peek</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">d</span></span> &lt; <span class="e Int"><span class="n">0xDC00</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">d</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">d</span></span> = <span class="e Identifier"><span class="i">read</span></span></span>;</span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">d</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Plus"><span class="e Plus"><span class="e Int"><span class="n">0x10000</span></span> + <span class="e Paren">(<span class="e LShift"><span class="e Identifier"><span class="i">c</span></span> &lt;&lt; <span class="e Int"><span class="n">10</span></span></span>)</span></span> + <span class="e Identifier"><span class="i">d</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xD800</span></span></span> || <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Identifier"><span class="i">c</span></span></span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">d</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">c</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Expression"><span class="e AndAssign"><span class="e Identifier"><span class="i">d</span></span> &amp;= <span class="e Int"><span class="n">0x3FF</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Plus"><span class="e Plus"><span class="e Int"><span class="n">0x10000</span></span> + <span class="e Paren">(<span class="e LShift"><span class="e Identifier"><span class="i">d</span></span> &lt;&lt; <span class="e Int"><span class="n">10</span></span></span>)</span></span> + <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"\uFFFD"w</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">//          UTF-32</span>
<span class="lc">//=============================================================================</span>

<span class="d Template"><span class="k">template</span> <span class="i">EncoderInstance</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span>:<span class="t Integral"><span class="k">dchar</span></span></span>)</span>
<span class="d Compound">{
    <span class="d Alias"><span class="k">alias</span> <span class="d Variables"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">dchar</span></span>)</span><span class="t Array">[]</span> <span class="i">EString</span>;</span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"UTF-32"</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">canEncode</span></span>(<span class="i">c</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Int"><span class="n">1</span></span>;</span>
    }</span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encodeViaWrite</span><span class="o TemplateParameters">()</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">write</span></span>(<span class="k">cast</span>(<span class="k">dchar</span>)<span class="i">c</span>)</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">skipViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">read</span></span>()</span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Identifier"><span class="i">read</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecodeViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Identifier"><span class="i">read</span></span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Cond"><span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span> ? <span class="e Identifier"><span class="i">c</span></span> : <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverseViaRead</span><span class="o TemplateParameters">()</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span>)<span class="e Identifier"><span class="i">read</span></span></span>;</span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">EString</span></span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"\uFFFD"d</span></span>;</span>
    }</span></span></span>

    <span class="d Mixin"><span class="k">mixin</span> <span class="e Identifier"><span class="i">EncoderFunctions</span></span>;</span>
}</span></span>

<span class="lc">//=============================================================================</span>
<span class="lc">// Below are forwarding functions which expose the function to the user</span>

<span class="bc">/**
 * Returns true if c is a valid code point
 *
 * Note that this includes the non-character code points U+FFFE and U+FFFF,
 * since these are valid code points (even though they are not valid
 * characters).
 *
 * Supercedes:
 * This function supercedes std.utf.startsValidDchar().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be tested
 */</span>
<span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodePoint</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e OrOr"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0xD800</span></span></span> || <span class="e Paren">(<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0xE000</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x110000</span></span></span></span>)</span></span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the name of an encoding.
 *
 * The type of encoding cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding type.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Examples:
 * -----------------------------------
 * writefln(encodingName!(Latin1Char));
 *     // writes ISO-8859-1
 * -----------------------------------
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">T</span></span>)</span><span class="o Parameters">()</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">T</span></span></span>)</span>.<span class="e Identifier"><span class="i">encodingName</span></span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span> == <span class="e String"><span class="sl">"UTF-8"</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">wchar</span></span></span>)</span> == <span class="e String"><span class="sl">"UTF-16"</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">dchar</span></span></span>)</span> == <span class="e String"><span class="sl">"UTF-32"</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">AsciiChar</span></span></span>)</span> == <span class="e String"><span class="sl">"ASCII"</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Latin1Char</span></span></span>)</span> == <span class="e String"><span class="sl">"ISO-8859-1"</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e TemplateInstance"><span class="i">encodingName</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span> == <span class="e String"><span class="sl">"windows-1252"</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns true iff it is possible to represent the specifed codepoint
 * in the encoding.
 *
 * The type of encoding cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding type.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Examples:
 * -----------------------------------
 * writefln(canEncode!(Latin1Char)('A'));
 *     // writes true
 * -----------------------------------
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">canEncode</span></span></span>(<span class="i">c</span>)</span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">AsciiChar</span></span></span>)</span></span>(<span class="cl">'\u00A0'</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Latin1Char</span></span></span>)</span>(<span class="cl">'\u00A0'</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span>(<span class="cl">'\u20AC'</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span></span>(<span class="cl">'\u20AD'</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span></span>(<span class="cl">'\uFFFD'</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span></span>(<span class="k">cast</span>(<span class="k">dchar</span>)<span class="n">0x110000</span>)</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns true if the code unit is legal. For example, the byte 0x80 would
 * not be legal in ASCII, because ASCII code units must always be in the range
 * 0x00 to 0x7F.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code unit to be tested
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValidCodeUnit</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="i">c</span>)</span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="k">cast</span>(<span class="i">AsciiChar</span>)<span class="n">0xA0</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>( <span class="e Call"><span class="e Identifier"><span class="i">isValidCodeUnit</span></span>(<span class="k">cast</span>(<span class="i">Windows1252Char</span>)<span class="n">0x80</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="k">cast</span>(<span class="i">Windows1252Char</span>)<span class="n">0x81</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="k">cast</span>(<span class="k">char</span>)<span class="n">0xC0</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="k">cast</span>(<span class="k">char</span>)<span class="n">0xFF</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>( <span class="e Call"><span class="e Identifier"><span class="i">isValidCodeUnit</span></span>(<span class="k">cast</span>(<span class="k">wchar</span>)<span class="n">0xD800</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Not">!<span class="e Identifier"><span class="i">isValidCodeUnit</span></span></span>(<span class="k">cast</span>(<span class="k">dchar</span>)<span class="n">0xD800</span>)</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns true if the string is encoded correctly
 *
 * Supercedes:
 * This function supercedes std.utf.validate(), however note that this
 * function returns a bool indicating whether the input was valid or not,
 * wheras the older funtion would throw an exception.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be tested
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValid</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">d</span> = <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">s</span>)</span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">d</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)
            <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span>
    }</span></span>
    <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="sl">"\u20AC100"</span>)</span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the length of the longest possible substring, starting from
 * the first code unit, which is validly encoded.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be tested
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">validLength</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">r</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
    <span class="s Compound">{
        <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">s</span>)</span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)
            <span class="s Break"><span class="k">break</span>;</span></span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Identifier"><span class="i">s</span></span></span>;</span>
    }</span></span>
    <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">r</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Sanitizes a string by replacing malformed code unit sequences with valid
 * code unit sequences. The result is guaranteed to be valid for this encoding.
 *
 * If the input string is already valid, this function returns the original,
 * otherwise it constructs a new string by replacing all illegal code unit
 * sequences with the encoding's replacement character, Invalid sequences will
 * be replaced with the Unicode replacement character (U+FFFD) if the
 * character repertoire contains it, otherwise invalid sequences will be
 * replaced with '?'.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be sanitized
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">sanitize</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">s</span>)</span>;</span></span>
    <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">s</span></span>;</span></span>

    <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">repSeq</span> = <span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">replacementSequence</span></span></span>;</span></span>

        <span class="lc">// Count how long the string needs to be.</span>
        <span class="lc">// Overestimating is not a problem</span>
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">len</span> = <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span>;</span>
    <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">t</span>)</span>..<span class="e Dollar">$</span>]</span></span>;</span>
    }</span></span>

    <span class="lc">// Now do the write</span>
    <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">array</span> = <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">E</span></span><span class="t Array">[<span class="t Identifier"><span class="i">len</span></span>]</span></span>;</span></span>
    <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span></span>;</span>
    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">offset</span> = <span class="e Identifier"><span class="i">n</span></span>;</span></span>

    <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
    <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Identifier"><span class="i">offset</span></span>..<span class="e Plus"><span class="e Identifier"><span class="i">offset</span></span>+<span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">repSeq</span></span>[]</span></span>;</span>
        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">offset</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">n</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">t</span>)</span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Identifier"><span class="i">offset</span></span>..<span class="e Plus"><span class="e Identifier"><span class="i">offset</span></span>+<span class="e Identifier"><span class="i">n</span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span></span>;</span>
        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">offset</span></span> += <span class="e Identifier"><span class="i">n</span></span></span>;</span>
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
    }</span></span>
    <span class="s Return"><span class="k">return</span> <span class="e Slice"><span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">array</span></span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">offset</span></span>]</span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">sanitize</span></span>(<span class="sl">"hello \xF0\x80world"</span>)</span> == <span class="e String"><span class="sl">"hello \xEF\xBF\xBDworld"</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the length of the first encoded sequence.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be sliced
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">firstSequence</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span> <span class="lc">/// ditto</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">u</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">u</span>)</span> != <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">skip</span></span></span>(<span class="i">s</span>)</span>;</span>
    <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">firstSequence</span></span>(<span class="sl">"\u20AC1000"</span>)</span> == <span class="e Dot"><span class="e String"><span class="sl">"\u20AC"</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the length the last encoded sequence.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be sliced
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">lastSequence</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span> <span class="lc">/// ditto</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">decodeReverse</span></span></span>(<span class="i">s</span>)</span>;</span>
    <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">lastSequence</span></span>(<span class="sl">"1000\u20AC"</span>)</span> == <span class="e Dot"><span class="e String"><span class="sl">"\u20AC"</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the total number of code points encoded in a string.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Supercedes:
 * This function supercedes std.utf.toUCSindex().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be counted
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">count</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
    <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
    <span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">skip</span></span></span>(<span class="i">s</span>)</span>;</span>
        <span class="s Expression"><span class="e PreIncr">++<span class="e Identifier"><span class="i">n</span></span></span>;</span>
    }</span></span>
    <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">n</span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">count</span></span>(<span class="sl">"\u20AC100"</span>)</span> == <span class="e Int"><span class="n">4</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns the array index at which the (n+1)th code point begins.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Supercedes:
 * This function supercedes std.utf.toUTFindex().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be counted
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">index</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>,<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Identifier"><span class="i">n</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>) <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">skip</span></span></span>(<span class="i">s</span>)</span>;</span></span>
    <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">index</span></span>(<span class="sl">"\u20AC100"</span>,<span class="n">1</span>)</span> == <span class="e Int"><span class="n">3</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Decodes a single code point.
 *
 * This function removes one or more code units from the start of a string,
 * and returns the decoded code point which those code units represent.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Supercedes:
 * This function supercedes std.utf.decode(), however, note that the
 * function codePoints() supercedes it more conveniently.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string whose first code point is to be decoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
    <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">u</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">u</span>)</span> != <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">s</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Decodes a single code point from the end of a string.
 *
 * This function removes one or more code units from the end of a string,
 * and returns the decoded code point which those code units represent.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string whose first code point is to be decoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decodeReverse</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">decodeReverse</span></span></span>(<span class="i">s</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Decodes a single code point. The input does not have to be valid.
 *
 * This function removes one or more code units from the start of a string,
 * and returns the decoded code point which those code units represent.
 *
 * This function will accept an invalidly encoded string as input.
 * If an invalid sequence is found at the start of the string, this
 * function will remove it, and return the value INVALID_SEQUENCE.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string whose first code point is to be decoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">s</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Returns the number of code units required to encode a single code point.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding as a template parameter.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be encoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">encodedLength</span></span></span>(<span class="i">c</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Encodes a single code point.
 *
 * This function encodes a single code point into one or more code units.
 * It returns a string containing those code units.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding as a template parameter.
 *
 * Supercedes:
 * This function supercedes std.utf.encode(), however, note that the
 * function codeUnits() supercedes it more conveniently.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be encoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">encode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Encodes a single code point into an array.
 *
 * This function encodes a single code point into one or more code units
 * The code units are stored in a user-supplied fixed-size array,
 * which must be passed by reference.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding as a template parameter.
 *
 * Supercedes:
 * This function supercedes std.utf.encode(), however, note that the
 * function codeUnits() supercedes it more conveniently.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be encoded
 *
 * Returns:
 *          the number of code units written to the array
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">array</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">E</span></span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">array</span></span>;</span></span>
    <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">t</span>)</span>;</span>
    <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">array</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Encodes a single code point into a Buffer.
 *
 * This function encodes a single code point into one or more code units
 * The code units are stored in a growable buffer.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding as a template parameter.
 *
 * Supercedes:
 * This function supercedes std.utf.encode(), however, note that the
 * function codeUnits() supercedes it more conveniently.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be encoded
 */</span>
<span class="d StorageClass"><span class="k">deprecated</span> <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="k">ref</span> <span class="t TemplateInstance"><span class="i">Buffer</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span> <span class="i">buffer</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">buffer</span>)</span>;</span>
}</span></span></span></span></span></span>

<span class="bc">/**
 * Encodes a single code point to a delegate.
 *
 * This function encodes a single code point into one or more code units.
 * The code units are passed one at a time to the supplied delegate.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding as a template parameter.
 *
 * Supercedes:
 * This function supercedes std.utf.encode(), however, note that the
 * function codeUnits() supercedes it more conveniently.
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    c = the code point to be encoded
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">encode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">void</span></span> <span class="t Delegate"><span class="k">delegate</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">E</span></span></span>)</span></span> <span class="i">dg</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e TemplateInstance"><span class="i">EncoderInstance</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">dg</span>)</span>;</span>
}</span></span></span></span></span>

<span class="bc">/**
 * Returns a foreachable struct which can bidirectionally iterate over all
 * code points in a string.
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * You can foreach either
 * with or without an index. If an index is specified, it will be initialized
 * at each iteration with the offset into the string at which the code point
 * begins.
 *
 * Supercedes:
 * This function supercedes std.utf.decode().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the string to be decoded
 *
 * Examples:
 * --------------------------------------------------------
 * string s = "hello world";
 * foreach(c;codePoints(s))
 * {
 *     // do something with c (which will always be a dchar)
 * }
 * --------------------------------------------------------
 *
 * Note that, currently, foreach(c:codePoints(s)) is superior to foreach(c;s)
 * in that the latter will fall over on encountering U+FFFF.
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t TemplateInstance"><span class="i">CodePoints</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span> <span class="i">codePoints</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">E</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e TemplateInstance"><span class="i">CodePoints</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>(<span class="i">s</span>)</span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span> = <span class="e String"><span class="sl">"hello"</span></span>;</span></span>
    <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">t</span>;</span></span>
    <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">c</span></span></span>;<span class="e Call"><span class="e Identifier"><span class="i">codePoints</span></span>(<span class="i">s</span>)</span>)
    <span class="s Compound">{
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">t</span></span> ~= <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">char</span></span>)<span class="e Identifier"><span class="i">c</span></span></span></span>;</span>
    }</span></span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">s</span></span> == <span class="e Identifier"><span class="i">t</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Returns a foreachable struct which can bidirectionally iterate over all
 * code units in a code point.
 *
 * The input to this function MUST be a valid code point.
 * This is enforced by the function's in-contract.
 *
 * The type of the output cannot be deduced. Therefore, it is necessary to
 * explicitly specify the encoding type in the template parameter.
 *
 * Supercedes:
 * This function supercedes std.utf.encode().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    d = the code point to be encoded
 *
 * Examples:
 * --------------------------------------------------------
 * dchar d = '\u20AC';
 * foreach(c;codeUnits!(char)(d))
 * {
 *     writefln("%X",c)
 * }
 * // will print
 * // E2
 * // 82
 * // AC
 * --------------------------------------------------------
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t TemplateInstance"><span class="i">CodeUnits</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span> <span class="i">codeUnits</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">E</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValidCodePoint</span></span>(<span class="i">c</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e TemplateInstance"><span class="i">CodeUnits</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">E</span></span></span>)</span>(<span class="i">c</span>)</span>;</span>
}</span></span></span></span></span>

<span class="d Unittest"><span class="k">unittest</span>
<span class="s FuncBody"><span class="s Compound">{
    <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span> <span class="i">a</span>;</span></span>
    <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">c</span></span></span>;<span class="e Call"><span class="e TemplateInstance"><span class="i">codeUnits</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span>(<span class="k">cast</span>(<span class="k">dchar</span>)<span class="cl">'\u20AC'</span>)</span>)
    <span class="s Compound">{
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">a</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span>
    }</span></span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">a</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> == <span class="e Int"><span class="n">3</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">a</span></span>[<span class="e Int"><span class="n">0</span></span>]</span> == <span class="e Int"><span class="n">0xE2</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">a</span></span>[<span class="e Int"><span class="n">1</span></span>]</span> == <span class="e Int"><span class="n">0x82</span></span></span>)</span>;</span>
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Index"><span class="e Identifier"><span class="i">a</span></span>[<span class="e Int"><span class="n">2</span></span>]</span> == <span class="e Int"><span class="n">0xAC</span></span></span>)</span>;</span>
}</span></span></span>

<span class="bc">/**
 * Convert a string from one encoding to another. (See also to!() below).
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Supercedes:
 * This function supercedes std.utf.toUTF8(), std.utf.toUTF16() and
 * std.utf.toUTF32()
 * (but note that to!() supercedes it more conveniently).
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    s = the source string
 *    r = the destination string
 *
 * Examples:
 * --------------------------------------------------------
 * wstring ws;
 * transcode("hello world",ws);
 *     // transcode from UTF-8 to UTF-16
 *
 * Latin1String ls;
 * transcode(ws, ls);
 *     // transcode from UTF-16 to ISO-8859-1
 * --------------------------------------------------------
 */</span>
<span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">transcode</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">Src</span></span>,<span class="o TemplateTypeParameter"><span class="i">Dst</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Src</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>,<span class="o Parameter"><span class="k">out</span> <span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Dst</span></span>)</span><span class="t Array">[]</span> <span class="i">r</span></span>)</span>
<span class="s FuncBody"><span class="k">in</span>
<span class="s Compound">{
    <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
}</span>
<span class="k">body</span>
<span class="s Compound">{
    <span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Is"><span class="k">is</span>(<span class="t Identifier"><span class="i">Src</span></span>==<span class="t Identifier"><span class="i">Dst</span></span>)</span>)
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">r</span></span> = <span class="e Identifier"><span class="i">s</span></span></span>;</span>
    }</span>
    <span class="k">else</span> <span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Is"><span class="k">is</span>(<span class="t Identifier"><span class="i">Src</span></span>==<span class="t Identifier"><span class="i">AsciiChar</span></span>)</span>)
    <span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e TemplateInstance"><span class="i">transcode</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span>,<span class="t Identifier"><span class="i">Dst</span></span></span>)</span>(<span class="k">cast</span>(<span class="i">string</span>)<span class="i">s</span>,<span class="i">r</span>)</span>;</span>
    }</span>
    <span class="k">else</span>
    <span class="s Compound">{
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">Src</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e TemplateInstance"><span class="i">encode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Dst</span></span></span>)</span>(<span class="i">decode</span>(<span class="i">t</span>))</span></span>;</span>
        }</span></span>
    }</span></span></span>
}</span></span></span></span></span>

<span class="bc">/*
 * Convert a string from one encoding to another. (See also transcode() above).
 *
 * The input to this function MUST be validly encoded.
 * This is enforced by the function's in-contract.
 *
 * Supercedes:
 * This function supercedes std.utf.toUTF8(), std.utf.toUTF16() and
 * std.utf.toUTF32().
 *
 * Standards: Unicode 5.0, ASCII, ISO-8859-1, WINDOWS-1252
 *
 * Params:
 *    Dst = the destination encoding type
 *    s = the source string
 *
 * Examples:
 * -----------------------------------------------------------------------------
 * auto ws = to!(wchar)("hello world");  // transcode from UTF-8 to UTF-16
 * auto ls = to!(Latin1Char)(ws);            // transcode from UTF-16 to ISO-8859-1
 * -----------------------------------------------------------------------------
 */</span>
<span class="lc">// TODO: Commented out for no - to be moved to std.conv</span>
<span class="lc">// Dst to(Dst,Src)(invariant(Src)[] s)</span>
<span class="lc">// in</span>
<span class="lc">// {</span>
<span class="lc">//  assert(isValid(s));</span>
<span class="lc">// }</span>
<span class="lc">// body</span>
<span class="lc">// {</span>
<span class="lc">//  Dst r;</span>
<span class="lc">//  transcode(s,r);</span>
<span class="lc">//  return r;</span>
<span class="lc">// }</span>

<span class="lc">//=============================================================================</span>

<span class="bc">/** The base class for exceptions thrown by this module */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingException</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">Exception</span></span></span> <span class="d Compound">{ <span class="d Constructor"><span class="k">this</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">string</span></span> <span class="i">msg</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Call"><span class="e Super"><span class="k">super</span></span>(<span class="i">msg</span>)</span>;</span> }</span></span></span> }</span></span>

<span class="d Class"><span class="k">class</span> <span class="i">UnrecognizedEncodingException</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingException</span></span></span>
<span class="d Compound">{
    <span class="d Protection"><span class="k">private</span> <span class="d Constructor"><span class="k">this</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">string</span></span> <span class="i">msg</span></span>)</span> <span class="s FuncBody"><span class="s Compound">{ <span class="s Expression"><span class="e Call"><span class="e Super"><span class="k">super</span></span>(<span class="i">msg</span>)</span>;</span> }</span></span></span></span>
}</span></span>

<span class="bc">/** Abstract base class of all encoding schemes */</span>
<span class="d StorageClass"><span class="k">abstract</span> <span class="d Class"><span class="k">class</span> <span class="i">EncodingScheme</span>
<span class="d Compound">{
    <span class="bc">/**
     * Registers a subclass of EncodingScheme.
     *
     * This function allows user-defined subclasses of EncodingScheme to
     * be declared in other modules.
     *
     * Examples:
     * ----------------------------------------------
     * class Amiga1251 : EncodingScheme
     * {
     *     static this()
     *     {
     *         EncodingScheme.register("path.to.Amiga1251");
     *     }
     * }
     * ----------------------------------------------
     */</span>
    <span class="d StorageClass"><span class="k">static</span> <span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">register</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">string</span></span> <span class="i">className</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">scheme</span> = <span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">EncodingScheme</span></span>)<span class="e Identifier"><span class="i">ClassInfo</span></span></span>.<span class="e Identifier"><span class="i">find</span></span></span>(<span class="i">className</span>)</span>.<span class="e Identifier"><span class="i">create</span></span></span>()</span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Identity"><span class="e Identifier"><span class="i">scheme</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
            <span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">EncodingException</span></span>(<span class="e Cat"><span class="e String"><span class="sl">"Unable to create class "</span></span>~<span class="e Identifier"><span class="i">className</span></span></span>)</span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">encodingName</span></span></span>;<span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">scheme</span></span>.<span class="e Identifier"><span class="i">names</span></span></span>()</span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assign"><span class="e Index"><span class="e Identifier"><span class="i">supported</span></span>[<span class="e Call"><span class="e Identifier"><span class="i">tolower</span></span>(<span class="i">encodingName</span>)</span>]</span> = <span class="e Identifier"><span class="i">className</span></span></span>;</span>
        }</span></span>
    }</span></span></span></span>

    <span class="bc">/**
     * Obtains a subclass of EncodingScheme which is capable of encoding
     * and decoding the named encoding scheme.
     *
     * This function is only aware of EncodingSchemes which have been
     * registered with the register() function.
     *
     * Examples:
     * ---------------------------------------------------
     * auto scheme = EncodingScheme.create("Amiga-1251");
     * ---------------------------------------------------
     */</span>
    <span class="d StorageClass"><span class="k">static</span> <span class="d Function"><span class="t Identifier"><span class="i">EncodingScheme</span></span> <span class="i">create</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">string</span></span> <span class="i">encodingName</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">p</span> = <span class="e In"><span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">string</span></span></span>.<span class="e Identifier"><span class="i">tolower</span></span></span>(<span class="i">encodingName</span>)</span> <span class="k">in</span> <span class="e Identifier"><span class="i">supported</span></span></span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Identity"><span class="e Identifier"><span class="i">p</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>)
            <span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">EncodingException</span></span>(<span class="e Cat"><span class="e String"><span class="sl">"Unrecognized Encoding: "</span></span>~<span class="e Identifier"><span class="i">encodingName</span></span></span>)</span>;</span></span>
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">className</span> = <span class="e Deref">*<span class="e Identifier"><span class="i">p</span></span></span>;</span></span>
        <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">scheme</span> = <span class="e Call"><span class="e Dot"><span class="e Call"><span class="e Dot"><span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">EncodingScheme</span></span>)<span class="e Identifier"><span class="i">ClassInfo</span></span></span>.<span class="e Identifier"><span class="i">find</span></span></span>(<span class="i">className</span>)</span>.<span class="e Identifier"><span class="i">create</span></span></span>()</span>;</span></span>
        <span class="s If"><span class="k">if</span> (<span class="e Identity"><span class="e Identifier"><span class="i">scheme</span></span> <span class="k">is</span> <span class="e Null"><span class="k">null</span></span></span>) <span class="s Throw"><span class="k">throw</span> <span class="e New"><span class="k">new</span> <span class="t Identifier"><span class="i">EncodingException</span></span>(<span class="e Cat"><span class="e String"><span class="sl">"Unable to create class "</span></span>~<span class="e Identifier"><span class="i">className</span></span></span>)</span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">scheme</span></span>;</span>
    }</span></span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="bc">/**
         * Returns the standard name of the encoding scheme
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span><span class="s FuncBody">;</span></span></span></span>

        <span class="bc">/**
         * Returns an array of all known names for this encoding scheme
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Returns true if the character c can be represented
         * in this encoding scheme.
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Returns the number of ubytes required to encode this code point.
         *
         * The input to this function MUST be a valid code point.
         *
         * Params:
         *    c = the code point to be encoded
         *
         * Returns:
         *    the number of ubytes required.
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Encodes a single code point into a user-supplied, fixed-size buffer.
         *
         * This function encodes a single code point into one or more ubytes.
         * The supplied buffer must be code unit aligned.
         * (For example, UTF-16LE or UTF-16BE must be wchar-aligned,
         * UTF-32LE or UTF-32BE must be dchar-aligned, etc.)
         *
         * The input to this function MUST be a valid code point.
         *
         * Params:
         *    c = the code point to be encoded
         *
         * Returns:
         *    the number of ubytes written.
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Decodes a single code point.
         *
         * This function removes one or more ubytes from the start of an array,
         * and returns the decoded code point which those ubytes represent.
         *
         * The input to this function MUST be validly encoded.
         *
         * Params:
         *    s = the array whose first code point is to be decoded
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Decodes a single code point. The input does not have to be valid.
         *
         * This function removes one or more ubytes from the start of an array,
         * and returns the decoded code point which those ubytes represent.
         *
         * This function will accept an invalidly encoded array as input.
         * If an invalid sequence is found at the start of the string, this
         * function will remove it, and return the value INVALID_SEQUENCE.
         *
         * Params:
         *    s = the array whose first code point is to be decoded
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span><span class="s FuncBody">;</span></span></span>

        <span class="bc">/**
         * Returns the sequence of ubytes to be used to represent
         * any character which cannot be represented in the encoding scheme.
         *
         * Normally this will be a representation of some substitution
         * character, such as U+FFFD or '?'.
         */</span>
        <span class="d StorageClass"><span class="k">abstract</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span><span class="s FuncBody">;</span></span></span>
    }</span></span>

    <span class="bc">/**
     * Returns true if the array is encoded correctly
     *
     * Params:
     *    s = the array to be tested
     */</span>
    <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">isValid</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">d</span> = <span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">s</span>)</span>;</span></span>
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">d</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)
                <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">false</span></span>;</span></span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Bool"><span class="k">true</span></span>;</span>
    }</span></span></span>

    <span class="bc">/**
     * Returns the length of the longest possible substring, starting from
     * the first element, which is validly encoded.
     *
     * Params:
     *    s = the array to be tested
     */</span>
    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">validLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">r</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">s</span>)</span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>) <span class="s Break"><span class="k">break</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Identifier"><span class="i">s</span></span></span>;</span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">r</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
    }</span></span></span>

    <span class="bc">/**
     * Sanitizes an array by replacing malformed ubyte sequences with valid
     * ubyte sequences. The result is guaranteed to be valid for this
     * encoding scheme.
     *
     * If the input array is already valid, this function returns the
     * original, otherwise it constructs a new array by replacing all illegal
     * sequences with the encoding scheme's replacement sequence.
     *
     * Params:
     *    s = the string to be sanitized
     */</span>
    <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">sanitize</span><span class="o Parameters">(<span class="o Parameter"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
                <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">s</span>)</span>;</span></span>
                <span class="s If"><span class="k">if</span> (<span class="e Equal"><span class="e Identifier"><span class="i">n</span></span> == <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>) <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">s</span></span>;</span></span>

                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">repSeq</span> = <span class="e Identifier"><span class="i">replacementSequence</span></span>;</span></span>

                <span class="lc">// Count how long the string needs to be.</span>
                <span class="lc">// Overestimating is not a problem</span>
                <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">len</span> = <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span>;</span></span>
                <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span>;</span>
                <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
                <span class="s Compound">{
                        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">t</span>)</span>;</span></span>
                        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
                        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">len</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
                        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">t</span>)</span>..<span class="e Dollar">$</span>]</span></span>;</span>
                }</span></span>

                <span class="lc">// Now do the write</span>
                <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">array</span> = <span class="e New"><span class="k">new</span> <span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[<span class="t Identifier"><span class="i">len</span></span>]</span></span>;</span></span>
                <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span></span>;</span>
                <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">offset</span> = <span class="e Identifier"><span class="i">n</span></span>;</span></span>

                <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
                <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
                <span class="s Compound">{
                        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">t</span>)</span>;</span></span>
                        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Identifier"><span class="i">c</span></span> == <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
                        <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Identifier"><span class="i">offset</span></span>..<span class="e Plus"><span class="e Identifier"><span class="i">offset</span></span>+<span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">repSeq</span></span>[]</span></span>;</span>
                        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">offset</span></span> += <span class="e Dot"><span class="e Identifier"><span class="i">repSeq</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
                        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">n</span></span> = <span class="e Call"><span class="e Identifier"><span class="i">validLength</span></span>(<span class="i">t</span>)</span></span>;</span>
                        <span class="s Expression"><span class="e Assign"><span class="e Slice"><span class="e Identifier"><span class="i">array</span></span>[<span class="e Identifier"><span class="i">offset</span></span>..<span class="e Plus"><span class="e Identifier"><span class="i">offset</span></span>+<span class="e Identifier"><span class="i">n</span></span></span>]</span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">n</span></span>]</span></span>;</span>
                        <span class="s Expression"><span class="e PlusAssign"><span class="e Identifier"><span class="i">offset</span></span> += <span class="e Identifier"><span class="i">n</span></span></span>;</span>
                        <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">t</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">t</span></span>[<span class="e Identifier"><span class="i">n</span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
                }</span></span>
                <span class="s Return"><span class="k">return</span> <span class="e Slice"><span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">array</span></span></span>[<span class="e Int"><span class="n">0</span></span>..<span class="e Identifier"><span class="i">offset</span></span>]</span>;</span>
    }</span></span></span>

    <span class="bc">/**
     * Returns the length of the first encoded sequence.
     *
     * The input to this function MUST be validly encoded.
     * This is enforced by the function's in-contract.
     *
     * Params:
     *    s = the array to be sliced
     */</span>
    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">firstSequence</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">u</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Call"><span class="e Identifier"><span class="i">safeDecode</span></span>(<span class="i">u</span>)</span> != <span class="e Identifier"><span class="i">INVALID_SEQUENCE</span></span></span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">decode</span></span>(<span class="i">s</span>)</span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
    }</span></span></span>

    <span class="bc">/**
     * Returns the total number of code points encoded in a ubyte array.
     *
     * The input to this function MUST be validly encoded.
     * This is enforced by the function's in-contract.
     *
     * Params:
     *    s = the string to be counted
     */</span>
    <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">count</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">n</span> = <span class="e Int"><span class="n">0</span></span>;</span></span>
        <span class="s While"><span class="k">while</span> (<span class="e Equal"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> != <span class="e Int"><span class="n">0</span></span></span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">decode</span></span>(<span class="i">s</span>)</span>;</span>
            <span class="s Expression"><span class="e PreIncr">++<span class="e Identifier"><span class="i">n</span></span></span>;</span>
        }</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">n</span></span>;</span>
    }</span></span></span>

    <span class="bc">/**
     * Returns the array index at which the (n+1)th code point begins.
     *
     * The input to this function MUST be validly encoded.
     * This is enforced by the function's in-contract.
     *
     * Params:
     *    s = the string to be counted
     */</span>
    <span class="d Function"><span class="t Integral"><span class="k">int</span></span> <span class="i">index</span><span class="o Parameters">(<span class="o Parameter"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>,<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span></span>)</span>
    <span class="s FuncBody"><span class="k">in</span>
    <span class="s Compound">{
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Call"><span class="e Identifier"><span class="i">isValid</span></span>(<span class="i">s</span>)</span>)</span>;</span>
        <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Rel"><span class="e Identifier"><span class="i">n</span></span> &gt;= <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
    }</span>
    <span class="k">body</span>
    <span class="s Compound">{
        <span class="d Variables"><span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">t</span> = <span class="e Identifier"><span class="i">s</span></span>;</span>
        <span class="s For"><span class="k">for</span> (<span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">uint</span></span> <span class="i">i</span>=<span class="e Int"><span class="n">0</span></span>;</span></span> <span class="e Rel"><span class="e Identifier"><span class="i">i</span></span>&lt;<span class="e Identifier"><span class="i">n</span></span></span>; <span class="e PreIncr">++<span class="e Identifier"><span class="i">i</span></span></span>) <span class="s Expression"><span class="e Call"><span class="e Identifier"><span class="i">decode</span></span>(<span class="i">s</span>)</span>;</span></span>
        <span class="s Return"><span class="k">return</span> <span class="e Minus"><span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> - <span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">static</span> <span class="d Variables"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[<span class="t Identifier"><span class="i">string</span></span>]</span> <span class="i">supported</span>;</span></span>
}</span></span></span>

<span class="bc">/**
 * EncodingScheme to handle ASCII
 *
 * This scheme recognises the following names:
 *                 "ANSI_X3.4-1968",
 *                 "ANSI_X3.4-1986",
 *                 "ASCII",
 *                 "IBM367",
 *                 "ISO646-US",
 *                 "ISO_646.irv:1991",
 *                 "US-ASCII",
 *                 "cp367",
 *                 "csASCII"
 *                 "iso-ir-6",
 *                 "us"
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeASCII</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeASCII"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span>
            <span class="e ArrayLiteral">[
                <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)
                <span class="e String"><span class="sl">"ANSI_X3.4-1968"</span></span></span>,
                <span class="e String"><span class="sl">"ANSI_X3.4-1986"</span></span>,
                <span class="e String"><span class="sl">"ASCII"</span></span>,
                <span class="e String"><span class="sl">"IBM367"</span></span>,
                <span class="e String"><span class="sl">"ISO646-US"</span></span>,
                <span class="e String"><span class="sl">"ISO_646.irv:1991"</span></span>,
                <span class="e String"><span class="sl">"US-ASCII"</span></span>,
                <span class="e String"><span class="sl">"cp367"</span></span>,
                <span class="e String"><span class="sl">"csASCII"</span>
                <span class="sl">"iso-ir-6"</span></span>,
                <span class="e String"><span class="sl">"us"</span></span>
            ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"ASCII"</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">AsciiChar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>
        
        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">AsciiChar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">AsciiChar</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">AsciiChar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">AsciiChar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"?"</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="bc">/**
 * EncodingScheme to handle Latin-1
 *
 * This scheme recognises the following names:
 *                 "CP819",
 *                 "IBM819",
 *                 "ISO-8859-1",
 *                 "ISO_8859-1",
 *                 "ISO_8859-1:1987",
 *                 "csISOLatin1",
 *                 "iso-ir-100",
 *                 "l1",
 *                 "latin1"
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeLatin1</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeLatin1"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span>
            <span class="e ArrayLiteral">[
                <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">string</span></span>)
                <span class="e String"><span class="sl">"CP819"</span></span></span>,
                <span class="e String"><span class="sl">"IBM819"</span></span>,
                <span class="e String"><span class="sl">"ISO-8859-1"</span></span>,
                <span class="e String"><span class="sl">"ISO_8859-1"</span></span>,
                <span class="e String"><span class="sl">"ISO_8859-1:1987"</span></span>,
                <span class="e String"><span class="sl">"csISOLatin1"</span></span>,
                <span class="e String"><span class="sl">"iso-ir-100"</span></span>,
                <span class="e String"><span class="sl">"l1"</span></span>,
                <span class="e String"><span class="sl">"latin1"</span></span>
            ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"ISO-8859-1"</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Latin1Char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Latin1Char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">Latin1Char</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">Latin1Char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">Latin1Char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"?"</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="bc">/**
 * EncodingScheme to handle Windows-1252
 *
 * This scheme recognises the following names:
 *                 "windows-1252"
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeWindows1252</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeWindows1252"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span>
            <span class="e ArrayLiteral">[
                <span class="k">cast</span>(<span class="i">string</span>)
                <span class="sl">"windows-1252"</span>
            ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"windows-1252"</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Windows1252Char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Identifier"><span class="i">Windows1252Char</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">Windows1252Char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Identifier"><span class="i">Windows1252Char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"?"</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="bc">/**
 * EncodingScheme to handle UTF-8
 *
 * This scheme recognises the following names:
 *                 "UTF-8"
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeUtf8</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeUtf8"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span>
            <span class="e ArrayLiteral">[
                <span class="k">cast</span>(<span class="i">string</span>)
                <span class="sl">"UTF-8"</span>
            ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e String"><span class="sl">"UTF-8"</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">char</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">char</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"\uFFFD"</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="bc">/**
 * EncodingScheme to handle UTF-16 in native byte order
 *
 * This scheme recognises the following names:
 *                 "UTF-16LE" (little-endian architecture only)
 *                 "UTF-16BE" (big-endian architecture only)
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeUtf16Native</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeUtf16Native"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d Version"><span class="k">version</span>(<span class="i">LittleEndian</span>) <span class="d Compound">{ <span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">NAME</span> = <span class="e String"><span class="sl">"UTF-16LE"</span></span>;</span> }</span></span>
        <span class="d Version"><span class="k">version</span>(<span class="i">BigEndian</span>)    <span class="d Compound">{ <span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">NAME</span> = <span class="e String"><span class="sl">"UTF-16BE"</span></span>;</span> }</span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e ArrayLiteral">[ <span class="i">NAME</span> ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">NAME</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">wchar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">wchar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">wchar</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Mul"><span class="e TypeDotId"><span class="t Integral"><span class="k">wchar</span></span>.<span class="i">sizeof</span></span> * <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="k">in</span>
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> &amp; <span class="e Int"><span class="n">1</span></span></span>)</span> == <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
        }</span>
        <span class="k">body</span>
        <span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">wchar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="k">in</span>
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> &amp; <span class="e Int"><span class="n">1</span></span></span>)</span> == <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
        }</span>
        <span class="k">body</span>
        <span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">wchar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"\uFFFD"w</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="bc">/**
 * EncodingScheme to handle UTF-32 in native byte order
 *
 * This scheme recognises the following names:
 *                 "UTF-32LE" (little-endian architecture only)
 *                 "UTF-32BE" (big-endian architecture only)
 */</span>
<span class="d Class"><span class="k">class</span> <span class="i">EncodingSchemeUtf32Native</span> : <span class="t BaseClass"><span class="t Identifier"><span class="i">EncodingScheme</span></span></span>
<span class="d Compound">{
    <span class="d StaticConstructor"><span class="k">static</span> <span class="k">this</span>()
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Expression"><span class="e Call"><span class="e Dot"><span class="e Identifier"><span class="i">EncodingScheme</span></span>.<span class="e Identifier"><span class="i">register</span></span></span>(<span class="sl">"std.encoding.EncodingSchemeUtf32Native"</span>)</span>;</span>
    }</span></span></span>

    <span class="d StorageClass"><span class="k">const</span>
    <span class="d Compound">{
        <span class="d Version"><span class="k">version</span>(<span class="i">LittleEndian</span>) <span class="d Compound">{ <span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">NAME</span> = <span class="e String"><span class="sl">"UTF-32LE"</span></span>;</span> }</span></span>
        <span class="d Version"><span class="k">version</span>(<span class="i">BigEndian</span>)    <span class="d Compound">{ <span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">NAME</span> = <span class="e String"><span class="sl">"UTF-32BE"</span></span>;</span> }</span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span><span class="t Array">[]</span> <span class="i">names</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e ArrayLiteral">[ <span class="i">NAME</span> ]</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">toString</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">NAME</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">bool</span></span> <span class="i">canEncode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">canEncode</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">dchar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encodedLength</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="s Return"><span class="k">return</span> <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e TemplateInstance"><span class="i">encodedLength</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">dchar</span></span></span>)</span></span>(<span class="i">c</span>)</span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">uint</span></span> <span class="i">encode</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span>, <span class="o Parameter"><span class="t Integral"><span class="k">ubyte</span></span><span class="t Array">[]</span> <span class="i">buffer</span></span>)</span>
        <span class="s FuncBody"><span class="s Compound">{
                <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">r</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Integral"><span class="k">dchar</span></span><span class="t Array">[]</span>)<span class="e Identifier"><span class="i">buffer</span></span></span>;</span></span>
            <span class="s Return"><span class="k">return</span> <span class="e Mul"><span class="e TypeDotId"><span class="t Integral"><span class="k">dchar</span></span>.<span class="i">sizeof</span></span> * <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">encode</span></span></span>(<span class="i">c</span>,<span class="i">r</span>)</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">decode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="k">in</span>
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> &amp; <span class="e Int"><span class="n">3</span></span></span>)</span> == <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
        }</span>
        <span class="k">body</span>
        <span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">dchar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">decode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">safeDecode</span><span class="o Parameters">(<span class="o Parameter"><span class="k">ref</span> <span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>)</span>
        <span class="s FuncBody"><span class="k">in</span>
        <span class="s Compound">{
            <span class="s Expression"><span class="e Assert"><span class="k">assert</span>(<span class="e Equal"><span class="e Paren">(<span class="e And"><span class="e Dot"><span class="e Identifier"><span class="i">s</span></span>.<span class="e Identifier"><span class="i">length</span></span></span> &amp; <span class="e Int"><span class="n">3</span></span></span>)</span> == <span class="e Int"><span class="n">0</span></span></span>)</span>;</span>
        }</span>
        <span class="k">body</span>
        <span class="s Compound">{
            <span class="d StorageClass"><span class="k">auto</span> <span class="d Variables"><span class="i">t</span> = <span class="e Cast"><span class="k">cast</span>(<span class="t Const"><span class="k">const</span>(<span class="t Integral"><span class="k">dchar</span></span>)</span><span class="t Array">[]</span>) <span class="e Identifier"><span class="i">s</span></span></span>;</span></span>
            <span class="s Declaration"><span class="d Variables"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span> = <span class="e Call"><span class="e Dot"><span class="e Dot"><span class="e Identifier"><span class="i">std</span></span>.<span class="e Identifier"><span class="i">encoding</span></span></span>.<span class="e Identifier"><span class="i">safeDecode</span></span></span>(<span class="i">t</span>)</span>;</span></span>
            <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">s</span></span> = <span class="e Slice"><span class="e Identifier"><span class="i">s</span></span>[<span class="e Minus"><span class="e Dollar">$</span>-<span class="e Dot"><span class="e Identifier"><span class="i">t</span></span>.<span class="e Identifier"><span class="i">length</span></span></span></span>..<span class="e Dollar">$</span>]</span></span>;</span>
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">c</span></span>;</span>
        }</span></span></span></span>

        <span class="d StorageClass"><span class="k">override</span> <span class="d Function"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span> <span class="i">replacementSequence</span><span class="o Parameters">()</span>
        <span class="s FuncBody"><span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Cast"><span class="k">cast</span>(<span class="t Invariant"><span class="k">invariant</span>(<span class="t Integral"><span class="k">ubyte</span></span>)</span><span class="t Array">[]</span>)<span class="e String"><span class="sl">"\uFFFD"d</span></span></span>;</span>
        }</span></span></span></span>
    }</span></span>
}</span></span>

<span class="lc">//=============================================================================</span>


<span class="lc">// Helper functions</span>
<span class="d Version"><span class="k">version</span>(<span class="k">unittest</span>)
<span class="d Compound">{
    <span class="d Template"><span class="d Compound"><span class="d Function"><span class="t Integral"><span class="k">void</span></span> <span class="i">transcodeReverse</span><span class="o TemplateParameters">(<span class="o TemplateTypeParameter"><span class="i">Src</span></span>,<span class="o TemplateTypeParameter"><span class="i">Dst</span></span>)</span><span class="o Parameters">(<span class="o Parameter"><span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Src</span></span>)</span><span class="t Array">[]</span> <span class="i">s</span></span>, <span class="o Parameter"><span class="k">out</span> <span class="t Invariant"><span class="k">invariant</span>(<span class="t Identifier"><span class="i">Dst</span></span>)</span><span class="t Array">[]</span> <span class="i">r</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Is"><span class="k">is</span>(<span class="t Identifier"><span class="i">Src</span></span>==<span class="t Identifier"><span class="i">Dst</span></span>)</span>)
        <span class="s Compound">{
            <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">s</span></span>;</span>
        }</span>
        <span class="k">else</span> <span class="s StaticIf"><span class="k">static</span> <span class="k">if</span>(<span class="e Is"><span class="k">is</span>(<span class="t Identifier"><span class="i">Src</span></span>==<span class="t Identifier"><span class="i">AsciiChar</span></span>)</span>)
        <span class="s Compound">{
            <span class="s Expression"><span class="e Call"><span class="e TemplateInstance"><span class="i">transcodeReverse</span>!(<span class="o TemplateArguments"><span class="t Integral"><span class="k">char</span></span>,<span class="t Identifier"><span class="i">Dst</span></span></span>)</span>(<span class="k">cast</span>(<span class="i">string</span>)<span class="i">s</span>,<span class="i">r</span>)</span>;</span>
        }</span>
        <span class="k">else</span>
        <span class="s Compound">{
            <span class="s Foreach"><span class="k">foreach_reverse</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">d</span></span></span>;<span class="e Call"><span class="e Identifier"><span class="i">codePoints</span></span>(<span class="i">s</span>)</span>)
            <span class="s Compound">{
                <span class="s Foreach"><span class="k">foreach_reverse</span>(<span class="o Parameters"><span class="o Parameter"><span class="i">c</span></span></span>;<span class="e Call"><span class="e TemplateInstance"><span class="i">codeUnits</span>!(<span class="o TemplateArguments"><span class="t Identifier"><span class="i">Dst</span></span></span>)</span>(<span class="i">d</span>)</span>)
                <span class="s Compound">{
                    <span class="s Expression"><span class="e Assign"><span class="e Identifier"><span class="i">r</span></span> = <span class="e Cat"><span class="e Identifier"><span class="i">c</span></span> ~ <span class="e Identifier"><span class="i">r</span></span></span></span>;</span>
                }</span></span>
            }</span></span>
        }</span></span></span>
    }</span></span></span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">makeReadable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">string</span></span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">r</span> = <span class="e String"><span class="sl">"\""</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Integral"><span class="k">char</span></span> <span class="i">c</span></span></span>;<span class="e Identifier"><span class="i">s</span></span>)
        <span class="s Compound">{
            <span class="s If"><span class="k">if</span> (<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x20</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span></span>)
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span>
            }</span>
            <span class="k">else</span>
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\\x"</span></span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">4</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span>)</span></span>;</span>
            }</span></span>
        }</span></span>
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\""</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">r</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">makeReadable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">wstring</span></span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">r</span> = <span class="e String"><span class="sl">"\""</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Integral"><span class="k">wchar</span></span> <span class="i">c</span></span></span>;<span class="e Identifier"><span class="i">s</span></span>)
        <span class="s Compound">{
            <span class="s If"><span class="k">if</span> (<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x20</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span></span>)
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span>
            }</span>
            <span class="k">else</span>
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\\u"</span></span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">12</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">8</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">4</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span>)</span></span>;</span>
            }</span></span>
        }</span></span>
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\"w"</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">r</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Identifier"><span class="i">string</span></span> <span class="i">makeReadable</span><span class="o Parameters">(<span class="o Parameter"><span class="t Identifier"><span class="i">dstring</span></span> <span class="i">s</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Declaration"><span class="d Variables"><span class="t Identifier"><span class="i">string</span></span> <span class="i">r</span> = <span class="e String"><span class="sl">"\""</span></span>;</span></span>
        <span class="s Foreach"><span class="k">foreach</span>(<span class="o Parameters"><span class="o Parameter"><span class="t Integral"><span class="k">dchar</span></span> <span class="i">c</span></span></span>;<span class="e Identifier"><span class="i">s</span></span>)
        <span class="s Compound">{
            <span class="s If"><span class="k">if</span> (<span class="e AndAnd"><span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &gt;= <span class="e Int"><span class="n">0x20</span></span></span> &amp;&amp; <span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x80</span></span></span></span>)
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Identifier"><span class="i">c</span></span></span>;</span>
            }</span>
            <span class="k">else</span> <span class="s If"><span class="k">if</span> (<span class="e Rel"><span class="e Identifier"><span class="i">c</span></span> &lt; <span class="e Int"><span class="n">0x10000</span></span></span>)
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\\u"</span></span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">12</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">8</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">4</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span>)</span></span>;</span>
            }</span>
            <span class="k">else</span>
            <span class="s Compound">{
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\\U00"</span></span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">20</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">16</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">12</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">8</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span> &gt;&gt; <span class="n">4</span>)</span></span>;</span>
                <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e Call"><span class="e Identifier"><span class="i">toHexDigit</span></span>(<span class="i">c</span>)</span></span>;</span>
            }</span></span></span>
        }</span></span>
        <span class="s Expression"><span class="e CatAssign"><span class="e Identifier"><span class="i">r</span></span> ~= <span class="e String"><span class="sl">"\"d"</span></span></span>;</span>
        <span class="s Return"><span class="k">return</span> <span class="e Identifier"><span class="i">r</span></span>;</span>
    }</span></span></span>

    <span class="d Function"><span class="t Integral"><span class="k">char</span></span> <span class="i">toHexDigit</span><span class="o Parameters">(<span class="o Parameter"><span class="t Integral"><span class="k">int</span></span> <span class="i">n</span></span>)</span>
    <span class="s FuncBody"><span class="s Compound">{
        <span class="s Return"><span class="k">return</span> <span class="e Index"><span class="e String"><span class="sl">"0123456789ABCDEF"</span></span>[<span class="e And"><span class="e Identifier"><span class="i">n</span></span> &amp; <span class="e Int"><span class="n">0xF</span></span></span>]</span>;</span>
    }</span></span></span>
}</span></span></span>


</pre></td>
</tr></table>
</body>
</html>